# Inverse Kinematics for Robotics using Neural Networks.

AI and Robotics

Oct 19, 2013 (4 years and 7 months ago)

91 views

Inverse Kinematics for Robotics
using Neural Networks.

Authors: Sreenivas Tejomurtula., Subhash Kak.

1998

Sub
-
Topics

Robotics.

Inverse Kinematics.

Neural Networks.

Robotics

Autonomous physical agents.

Sensors

observing the environment.

Actuators

changing the environment.

Typical in manufacturing industry.

Efficient at performing precise, simple repetitive
are too dangerous for humans.

Inverse Kinematics

The structure of a robotic manipulator consists
of a chain of rigid limbs connected by joints.
The end effector is the last part of the chain and
makes physical contact with the environment.

Kinematics works out the end effector
position(s) (x,y,z) as a function of the joint
angles

Inverse Kinematics is the opposite:

=
f((x,y,z)).

Inverse Kinematics says “take our goal position
and find how to get there”
-

(what angles are
required).

How to solve IK?

Analytical solutions.

Fast.

Design based

determines robot design.

Poor generalisation.

Handles singularities well.

Numerical methods.

Slow

Good generalisation to arbitrary robot design.

Handles singularities poorly.

Forward map for 2 planar arm

Neural Networks (A new alternative)

Train the neural network to learn the forward
mapping (typically).

“Invert” the neural network to find the input
angles of the forward mapping.

3 existing methods applied to IK:

Optimization: Approximate a non
-
linear function
between layers and solve using non
-
linear
programming.

Iterative: Given we know the desired output lets find
the best input
-
output mapping to match the output
by searching a path in input space.

Error back
-
propagation: Plug in the desired output
into the forward mapping network. Use back
-
propagation to propagate the error back to the input
units and so the input steps along input space and
let the weights revert back to their original settings
each iteration.

Neural Network architecture

Forward kinematics can be determined for most
manipulators except for those with redundant joints.

Good initial guess for input is made using “Corner
Classification”.

Since architecture is based on equations

no

training is required
!! IE, weights are taken from
equations.

Some of the weights are non
-
linear which makes
error back
-
propagation tricky. Eg, for sin and cos
weights we make a decision at the neighbourhood
to determine a sign change.

Once we have convergence we test to see
whether joint angles are within their allowable
range.

Conclusion

Useful in real
-
time applications as it generates many
accurate solutions quickly. Alternatively, Kohonen
maps require a long optimization process.

Although there are revolute, prismatic, helical,
cylindrical, spherical and planar joints, only revolute
and prismatic joints are regarded here. Also it does
not handle redundant joints.

Unlike numerical techniques, the computational
requirement is not based on the number of joints but
the network architecture.

Must generate good initial guesses for the input.