Solving the Inverse Kinematics problem using a neural network

Hello, I apologize for disturbing you.

I kindly ask you to help me with the task:

To solve the inverse kinematics of a 3-link planar manipulator, it is necessary to create and train a neural model. The creation and training of the neural model should be carried out using the Matlab package "Neural Net Fitting" (located in the Apps section).

To solve this problem, I built the manipulator's workspace through forward kinematics using Robotics Toolbox (45,000 points, singular points were excluded from the sample).

To train the neural network, I normalized the data of the coordinates of points and angles. But when constructing a given trajectory (circle and others), the network deviates greatly from the trajectory. I tried changing the number of points for generating the workspace (increased and decreased), changed the number of hidden layers and neurons in them, types of activation functions in the layers, but each time the neural network does not follow the trajectory.

I really ask for your help, tell me what I'm doing wrong, where the error has crept in. All the code and the created neural networks are attached to the letter (the code and the neural network were created in the online version of Matlab R2025a).

Thank you in advance.

[William Rose]

@po,

Why do you normalize the data, and how do you normalize it? I think it is good practice not to normalize data until there is a demonstrated advantage to doing so.

The inverse problem is to find the three joint angles that will move the end effector to a specified (x,y) point. The problem is underdetermined for a three-joint system, correct? How will the NN solve an underdetermined problem? You could minimize a cost function (for example, the sum of the absolute values of the joint angles), so that the problem is no longer underdetermined. Or you could compute and train the network on the pose (angle relative to the base coordinate system) of the third link, as well as the end effector position. Then the inverse problem would include a specification of the desired pose at each x,y location of the end-effector.

I hope my suggestions above are not trivially obvious. This is not an area with which I am familiar or experienced.

[po]

Good day, thank you for answering.

I normalize the data because the number of points is very large (45 thousand), I read that if there is a lot of data then it needs to be normalized and in the examples that I saw they did the same. Here is the part of the code where I normalize the data:

% Filtering non-singular points
coords = coords(non_singular_indices, :);
angles = angles(non_singular_indices, :);

% Normalization
coords_min = min(coords);
coords_max = max(coords);
coords_normalized = (coords - coords_min) ./ (coords_max - coords_min);

angles_min = [theta1_range(1), theta2_range(1), theta3_range(1)];
angles_max = [theta1_range(2), theta2_range(2), theta3_range(2)];
angles_normalized = (angles - angles_min) ./ (angles_max - angles_min);

Here is the code where I denormalize the points back (when constructing a trajectory with a neural network):

% Denormalization of angles
predicted_angles = predicted_angles_norm .* (angles_max - angles_min) + angles_min;

As far as I understand correctly, you suggest training a neural network not just on the coordinates of the final effector position (x, y, z) and the corresponding angles, but adding the Euler angle to the training sample?

Am I understanding you correctly?

[William Rose]

@po,

Thank you for explaining how you normalize your data. I now suspect that ther normalization which you are doing is not the cause of the dificulty you are experiencing. I say that because I tried solving this problem without normalizing the angles or the positions, and I have also failed to find a good solution, thus far.

You wrote: "You suggest training a neural network not just on the coordinates of the final effector position (x, y, z) and the corresponding angles, but adding the Euler angle to the training sample? Am I understanding you correctly?"

Your understanding is correct, if "Euler angle" means the angle of the third link, relative to the base coordinate system. I call this angle "phi" in my code. This angle is also called the "pose" by some authors. Therefore I sometimes refer to it as the pose in my code comments. The diagram below shows the pose angle, ϕ, and the three joint angles, . I propose that the inputs to the network should be , and the outputs, which the network should learn how to predict, are .

I have never used the deep learning toolbox or the robotics toolbox. When I look at your code, I do not understand it very well. I tried running the three scripts you attached. I got an error in every case.

>> workplace3_dobot__no_singular

Unrecognized function or variable 'Link'.

Error in workplace3_dobot__no_singular (line 11)

L(1) = Link([0, L_1, 43.5, -pi/2]);

>> testing__NN

Unrecognized function or variable 'Link'.

Error in testing__NN (line 10)

L(1) = Link([0, L_1, 43.5, -pi/2]);

>> NN_2layer

Unrecognized function or variable 'coords_normalized'.

Error in NN_2layer (line 9)

x = coords_normalized'; % (3 x N)

When I loaded trained_net.mat or trained_net2.mat, I got a warning error:

>> load('trained_net.mat')

Warning: Variable 'net' originally saved as a network cannot be instantiated as an

object and will be read in as a uint32.

Answer 1

[William Rose]

@po,

Since I was unable to run your code, I tried making my own code to solve the inverse kinematics problem of a three-link planar manipulator, using a neural network. I wrote one function and three scripts.

Function endPosPose.m implements the forward kinematics equations: given the link lengths and joint angles, it computes the end effector position and pose angle. The inputs to endPosPose() are the link length vector (L1,L2,L3) and the joint angle vector (t1,t2,t3). This function returns a vector containining (xe,ye,phi), which are the end effector position and the pose angle, shown in the diagram in my comment above.

Script threelinkManipulatorForward.m generates training data for the network. It calls function endPosPose.m.

Script trainFFNeuralNet.m defines and trains a feed-forward neural network.

Script predictFFNeuralNet.m uses the trained feed-forward network to predict joint angles needed to move along a desired trajectory. It uses the joint angles from the neural network to compute the end-effector position. It makes a plot and displays statistics about the errors between the actual trajectory and the desired trajectory. This script calls function endPosPose.m.

My attempt to use a neural network to solve the inverse kinematics problem of a three-link planar manipulator has been a failure, thus far. Two figures below illustrate examples of the failure. Each diagram shows the points on the desired trajectory in red, and the actual trajectory points in blue. Green line connect corresponding desired and actual points. In both cases, the desired trajectory consists of 24 equally spaced points on the unit circle.

Figure 1, below: Net1 is used to compute joint angles. The actual trajectory lies on a semicircular arc to the right of the desired circle, and with a radius that is too large.

Figure 2, below: Net4 is used to compute joint angles. The actual trajectory lies on the left half of the unit circle. When the desired pont is in the left-hand plane, the network prediction is not too bad. But when the desired point is in the right hand plane, the network prediction results in an actual position on the oppostite half of the circle.

In both cases above, a network with 50 neurons in one hidden layer was used.

The difference between Net1 and Net4 is that they were trained on different data. The training data for Net1 specified all angles in the range (-pi,+pi). The training data for Net4 specified all angles in the range (0, 2*pi).

I later tried using 100 neurons, instead of 50, in the hidden layer. This caused only a very small improvement. I also tried using two hidden layers, with 50 and 30 neurons. This also caused only a small improvement.

Future ideas:

• Use a non-default activation function.
• Use a non-default training algorithm.
• Use more neurons or more layers or both.
• Train three separate networks simultaneously - one for each of the three joint angles.

The attached pdf document contains more details about my attempt to solve the inverse kinematics problem of a three-link planar manipulator using a neural network.

[William Rose]

@po, I tried several ideas to improve performance, but none of the ideas led to significant improvement.

Training Algorithm: The default algorithm, which I had been using, is Levenberg-Marquardt (trainlm). I tried Bayesian regularization (trainbr) and scaled conjugate gradient back-propagation (trainscg). They both resulted in networks with worse performance than the default (Net4Abr and Net4Ascg worse than Net4).

Activation Function: The default hidden layer activation function is hyperbolic tangent ('tansig'). I tried ReLU activation function ('poslin'). This resulted in a network with sligtly worse performance than the default (Net4Arelu worse than Net4).

More Layers and Neurons: My original network (Net4) had one hidden layer with 50 neurons. I had already trained a network with one hidden layer with 100 neurons (Net4B), and I had trained a network with two hidden layers, with 50+30 neurons (Net4C). I then tried three hidden layers with 35+25+15 neurons (Net4D). The performance was slightly better than anything before, but the basic problem was not changed: the actual trajectory points that should have been on the unit circle in the right half plane were in the left half plane. See figure in attached document.

Normalization: I normalized all inputs and outputs to the network to be in the range [0,1], with a single hidden layer of 50 neurons. The resulting network (Net4E) did not perform better than the un-normalized equivalent (Net4).

Normalization + More Layers and Neurons: I normalized all inputs and outputs to [0,1] and I used three hidden layers with 35+25+15 neurons. The resulting network (Net4F) performed slightly worse than the un-normalized network with the same hidden layer architecture (Net4D).

The attached PDF document includes more information and figures about the unsuccessful attempts described here.

I am attaching two scripts, one function file, and one training data file. This will allow you to generate network Net4D, and test its predictions, using the following commands:

>> trainFFNeuralNetD

>> predictFFNeuralNet

Net4D is the best-performing network I have made so far, but it is not at all satisfactory. Your version of Net4D will not be exatctly the same as mine, due to stochastic aspects of the training process.

An idea I have not tried is to remove the pose angle (ϕ) from the problem. This makes the inverse kinematic problem under-determined.

[William Rose]

@po,

[Edit, 16 Aug 2025: Update pdf file. It now includes the analytic solution to the inverse kinematics problem.]

I tried making a network with three times as many hidden layer neurons [100,75,50]. It took about 1 hour to train, using the same training data as before (trainData4.mat). It did not perform any better than the network with [35,25,15] neurons.

Then I implented the idea which I mentioned in my previous comment: remove the pose angle from the problem. This makes the inverse kinematics problem under-determined: there are two inputs (xe,ye) and three oputputs (). The physical manifestation of the under-determined nature of the problem is that there are multiple joint angle combinations that result in the same end-effector position. The network with two inputs, three outputs, and three hidden layers with [35,25,15] neurons is Net4D2in. It performs equally well as Net4D, which has three inputs. It shows the same problem a before: when the desired trajectory points are on the right half of the unit circle, the actual points are on the left half. See figure below. I am attaching the code and training data that I used to train the network and predict trajectory points. You should be able to reproduce my results (except for some stochastic variability) by doing the commands below:

>> trainFFNN

>> predictFFNN

The attached PDF has been updated to include the recent results and discussion.

[po]

Hello, I apologize for not responding for so long. I really appreciate your help. I have also been trying to somehow improve my neural network and use other approaches to training, but so far all to no avail.

The error that occurs when you run my code indicates that you do not have the Matlab Robotics ToolBox package installed. To avoid this error, you need to install this package via Matlab - Apps - Install App - Select downloaded package.

>> workplace3_dobot__no_singular

Unrecognized function or variable 'Link'.

Unfortunately, the forum does not allow you to attach archives larger than 5 MB, so I am attaching a link to download this Matlab Robotics ToolBox package (You need to download a file called RTB10.4.mltbx): https://petercorke.com/toolboxes/robotics-toolbox/

You also said that you have this error:

"

When I loaded trained_net.mat or trained_net2.mat, I got a warning error:

>> load('trained_net.mat')

Warning: Variable 'net' originally saved as a network cannot be instantiated as an

object and will be read in as a uint32.

" it occurs because you are using a version of Matlab below R2025a. In order not to receive this error, you can use the online version of Matlab, for this you just need to register on the official Matlab website: https://nl.mathworks.com/products/matlab-online.html

Thanks again for your help. I am very grateful to you.

[William Rose]

@po,

Thank you for the link to the robotics toolbox and the information about using R2025 instead of R2024.

I understand that the Robotics Toolbox to which you refer is NOT the Matlab Robotics System toolbox (which I have, v.24.1). Your script uses functions from a non-Matlab toolbox by Peter Corke called the Robotic Toolbox, latest version is v.10.4. I do not want to install a non-Matlab toolbox to work on this question.

I cannot get the latest matlab (R2025), since I have retired. Therefore I use R2024a.

I have updated the pdf document attached above, to include the analytic solution to the inverse kinematic probelm. I wrote a function that implements the analytic solution to the inverse kinematics problem (attached). Perhaps it will be useful in determining why the neural net solution to the inverse probelm is not working. I am alo attaching a script I wrote to test the inverse kinematics function and demonstrate its use.