autodiff | Symbolic differentiation engine | Machine Learning library

I see the current chapter of Underactuated: System Identification and the corresponding notebook, and it currently does it through symbolics.

I'd like to try out stuff like system identification using forward-mode automatic differentiation ("autodiff" via AutoDiffXd, etc.), just to check things like scalability, get a better feel for symbolics and autodiff options in Drake, etc.

As a first steps towards system identification with autodiff, how do I take gradients of MultibodyPlant quantities (e.g. generalized forces, forward dynamics, etc.) with respect to inertial parameters (say mass)?

• Note: Permalinks of Underactuated chapter + notebook at time of writing: sysid.html, sysid.ipynb

I would like to convert a SymPy expression in order to use as an objetive function in JuMP. Suppose my variable involves two variables

I have been trying to get a linearized version of a MultiBodyPlant without gravity to experiment with LQR for systems without gravity. However, the linearization leads to some interesting phenomena. A simplified example can be found in this google colab notebook.

When I linearize and check the rank of the controllability matrix for a single free-floating rigid body, I get a rank of 6. This is expected as I use the get_applied_generalized_force_input_port() as the input port, hence making sure that all possible forces can be applied to the system. The system of a single rigid body has 6 degrees of freedom (DoF) and the rank of the controllability matrix is 6, hence it is controllable.

However, when I use Drake's in-built function IsControllable() to check the controllability, it results False meaning that it thinks the system is not controllable. In the source of the IsControllable() function, the rank of the matrix is checked against the number of rows in the A matrix. I think that this might be causing an issue as the linearization involves the use of quaternions during the AutoDiff (thus adding one more row to the A matrix due to 4 numbers being used for quaternions to represent the state). The linearization process does not know about the unit-quaternion constraint, and hence the A matrix for a system using quaternions will have 1 more row than the DoF of the system.

I wonder if this is the correct intuition for the controllability mismatch?

And could this cause issues as other functions within Drake that maybe use the IsControllable() function for verifying controllability?

By this I mean, can I include it in a loss function and have autodiff function properly?

The raw_ops docs (https://www.tensorflow.org/api_docs/python/tf/raw_ops) has no listing for sort or argsort.

Given a neural network with weights theta and inputs x, I am interested in calculating the partial derivatives of the neural network's output w.r.t. x, so that I can use the result when training the weights theta using a loss depending both on the output and the partial derivatives of the output. I figured out how to calculate the partial derivatives following this post. I also found this post that explains how to use sympy to achieve something similar, however, adapting it to a neural network context within pytorch seems like a huge amount of work and a recipee for very slow code.

Thus, I tried something different, which failed. As a minimal example, I created a function (substituting my neural network)

I am trying to convert the following pydrake code to C++ version. Unfortunately,I get lost in the very rigorous C++ API documentation. Could you help to convert the following code into C++ version for a tutorial? Thank you so much!

I am using PyDrake do build a simple model of a Franka Emika Panda robot arm which picks up and places a brick.

I would like to observe how a change in the initial chosen starting position of my brick affects a custom target loss function. Therefore, I would like to use the AutoDiffXd functionality built into Drake to automatically extract the derivative of my loss function at the end of simulation with respect to my initial inputs.

I build my system with as normal, then run ToAutoDiffXd() to convert the respective systems to an autodiff version. However, I get the following error:

newbie here

I'm trying to minimize a function in Julia with optim.jl. The function works, but when I try to optimize it it gives me this error message:

Does np.linalg.solve() not work for AutoDiff? I use is to solve manipulator equation. The error message is shown below. I try a similar "double" version code, it is no issue. Please tell me how to fix it, thanks!