INFORMATION
SCIENCES
AN ~I~/RNAT~O~AL JOURNAL
ELSEVIER Information Sciences 116 (1999) 147164
Inverse kinematics in robotics using neural
networks
Sreenivas Tejomurtula a,1, Subhash Kak b,.
a Avant! Corporation, 46871 BaysMe Parkway, Fremont, CA 94538, USA
b Department of Electrical and Computer EnghleerhTg, Louisiana State University,
Baton Rouge, LA 708035901, USA
Received 1 March 1998; accepted 23 October 1998
Communicated by George Georgiou
Abstract
The inverse kinematics problem in robotics requires the determination of the joint
angles for a desired position of the endeffector. For this underconstrained and illcon
ditioned problem we propose a solution based on structured neural networks that can be
trained quickly. The proposed method yields multiple and precise solutions and it is
suitable for realtime applications. © 1999 Elsevier Science Inc. All rights reserved.
I. Int roduct i on
Modern robot manipulators, and kinematic mechanisms in general, are
typically constructed by connecting different joints together using rigid links. A
number of links are attached serially by a set of actuated joints. The kinematics
of a robot mani pul at or describes the relationship between the mot i on of the
joints of a mani pul at or and resulting motion of the rigid bodies that form the
robot. Most of the modern manipulators consist of a set of rigid links con
nected together by a set of joints. Although any type of joint mechanism can be
used to connect the links of a robot, traditionally the joints are chosen from
revolute, prismatic, helical, cylindrical, spherical and planar joints. This paper
looks at manipulators with revolute and prismatic joints.
* Corresponding author. Email: kak@ee.lsu.edu
t Email: sreeni@avanticorp.com
00200255/99/$20.00 © 1999 Elsevier Science Inc. All rights reserved.
PII: S0020 0255( 98) 10098 1
148
S. Tejomurtula, S, Kak / hlformation Sciences 116 (1999) 147164
The different techniques used for solving inverse kinematics can be clas
sified as algebraic [6,17,14,4,12,18], geometric [10,1,7] and iterative [8]. The
algebraic methods do not guarantee closed form solutions. In case of geo
metric methods, closed form solutions for the first three joints of the ma
nipulator must exist geometrically. The iterative methods converge to only a
single solution and this solution depends on the starting point. The most
common neural networks used to solve the problem of inverse kinematics are
errorbackpropagation and Kohonen networks. The errorbackpropagation
algorithm takes a very long time for forward training. We have proposed a
variant of the errorbackpropagation algorithm to solve this problem. This
new approach has the advantage of accuracy over the errorbackpropagation
algorithm.
2. Background and notation
The forward kinematics of a robot determines the configuration of the end
effector (the gripper or tool mounted on the end of the robot), given the relative
configuration of the robot. This paper is restricted to openchain manipulators
in which the links form a single serial chain and each pair of links is connected
either by a revolute joint or a prismatic (sliding) joint.
The joint space of a manipulator consists of all possible values of the joint
variables of the robot. Specifying the joint angles specifies the location of all
the links of the robot. For revolute joints, the joint variables are given by an
angle q E [a, b) where a and b are angles in radians.
All joint angles are measured using a lefthanded coordinate system, so that
angle about a directed axis is positive if it represents an anticlockwise rotation
as viewed along the direction of the axis. Prismatic joints are described by a
linear displacement along a directed axis.
The number of degrees of freedom of an openchain manipulator is equal to
the number of joints in the manipulator. For simplicity, all joint variables are
referred to as angles, although both angles and displacements are allowed,
depending on the type of joint. Given a set of joint angles, the determination of
the configuration of the endeffector relative to the base is called forward ki
nematics.
The workspace of a manipulator is defined as the set of all endeffector
configurations that can be reached by some choice of joint angles. The work
space is used when planning a task for a manipulator to execute; all desired
motions of the manipulator must remain within the workspace. In this paper,
the range of the possible angles is fixed in advance and the reachable workspace
is calculated.
Given the desired endeffector position, the problem of finding the values of
the joint variables in order for the manipulator to reach that position is inverse
S. Tejomurtula, S. Kak I Information Sciences 116 (1999) 147164 149
kinematics. This problem may have multiple solutions, a unique solution or no
solution.
2.1. A planar exampl e
To illustrate some of the issues in inverse kinematics, consider the inverse
kinematics of the planar twolink manipulator shown in Fig. 1.
The forward kinematics can be determined using plane geometry.
p, = L, cos(q,) + L2cos(q, + q2), (1)
P2 = L1 sin (ql) + Lzsin(ql + q2). (2)
The inverse problem is to solve for joint variables ql and q2, given the end
effector coordinates pl and Pz.
q2 = n rk a,
a = cos' ((L~ + L]  r2)/(2LIL2)),
ql = at an(p2,pl ) 4 b,
b = cos' ((r 2 + L~  L~)/2L,r).
(3)
(4)
(5)
(6)
L /
ss s~
Fig. 1. Inverse kinematics of a twolink manipulator.
150 s. Tejomurtula, S. Kak I hformation Sciences 116 (1999) 147164
2.2. Different methods used f or solv#zg inverse kinematics
The three main methods for solving inverse kinematics, namely, algebraic,
geometric and iterative are described below.
Algebraic: Detailed steps toward an algebraic solution to the PUMA 500
manipulator can be found in Refs. [17,14,4]. To solve for inverse kinematics
algebraically, it is necessary to solve equations q~,q2,..., qu for N degrees of
freedom. The problem can be formulated as follows: given the endeffector
position
= 0 0 l
(7)
where the righthand side describes the required position and orientation of the
endeffector. The problem comes down to solving N equations for N un
knowns [14]. This method does not guarantee a closed form solution for a
given manipulator. Thus, engineers usually design simple manipulators where
closedform solutions exist.Craig [4], Manocha [12] and Zhu [18] proposed a
generalized closedform solution which can be derived for 6 (or less) DOF
kinematic chain. Manocha [12] outlined a method for solving IK algebraically
using symbolic manipulation to derive univariate polynomial and matrix
computations.
Geometric: As opposed to the algebraic method, a closed form solution
using the geometry of the manipulator is derived. Lee [10] used theorems in
coordinate geometry which can be found in Ref. [1] to derive closed form
solutions for a six DOF manipulator. This involves projecting of the link co
ordinate frame on the X~_l and Y~_l frame. This method can be applied to any
manipulator with known geometry. The limitation of this method is that the
closedform solution for the first three joints of the manipulator must exist
geometrically [7]. Apart from that, the closedform solution for one class of
manipulators cannot be used in other manipulators of a different geometry.
Iterative: This method solves inverse kinematics by iteratively solving for the
joint angles. This method converges to only one solution as opposed to the two
methods presented by Korein and Balder [8]. There are three components that
constitute iterative methods, namely, the Jacobian, pseudoinverse and mini
mization methods.
The inverse kinematics problem using neural networks comes under the
class of iterative methods. They are however different from the conventional
iterative methods used for solving inverse kinematics. It is important to note
that the computational requirements are independent of the number of degrees
of freedom of the robot arm; instead they are based on the network archi
tecture.
S. Tejomurtula, S. Kak I hformation Sciences 116 (1999) 147164
3. Application of neural networks in inverse kinematics
151
In robotics, solving a problem using a programmed approach requires the
development of software to implement the algorithm or set of rules. Frequently
there are situations as in nonlinear or complex multivariable systems, where
the set of rules or required algorithms is unknown or too complex to be
accurately modeled. Even if characterizing algorithms are obtained, they
often are too computationally intensive for practical realtime applications.
To circumvent this problem, neural networks are used. Neural networks are
advantageous because they reduce software development, decrease computa
tional requirements, and allow for information processing capabilities where
algorithms or rules are not known or cannot be derived.
The computational requirements for task and path planning, and path
control, may be very demanding. However, robotic processes may be formu
lated in terms of optimization or pattern recognition problems so that neural
network can be adapted.
3.1. Backpropagation
The conventional backpropagation algorithm is as follows: The number of
hidden layers and the number of hidden neurons in each layer are decided. The
network is fully connected between every two adjacent layers, i.e., the input
neurons and the hidden neurons in the first hidden layer are fully connected.
There is a connection between every pair of neurons between hidden layer 1
and hidden layer 2 and so on. The neurons in the final hidden layer are
completely connected to the output layer. The weights of these connections are
chosen at random. The first pattern is fed and its response is transported to the
output layer. The error between the desired output and the actual output is
propagated back. The weights are adjusted iteratively till the error falls below a
threshold. Similarly all input patterns of the training set are fed and weights are
adjusted. This process goes on till all the patterns are stored simultaneously.
The amount of time taken for training makes it practically useless for real
time applications if the training set is very large.
3.2. Neural network inversions
The inversion problem for neural networks is to find inputs that yield a
desired output [11]. There are three commonly used approaches for inverting
networks. These are error backpropogation approach, the optimization ap
proach and the iterative approach based on update of input vector.
Optimization: In the optimization approach [9], the inversion problem is
formulated as a nonlinear programming problem. The neural network is
trained using data points. Once the training is done, the weights are fixed. The
152 S. Tejomurtula, S. Kak / Information Sciences 116 (1999) 147164
relation between every two hidden layers is approximated as a nonlinear
function. These equations are solved along with the constraint inequalities on
the joint variables. A nonlinear programming problem where the objective
and the constraint functions can be expressed as a sum of functions, each in
volving only one variable, is called a nonlinear separable programming
problem. It can be approximated as a pseudolinear programming problem and
solved by a variation of the simplex method, a common technique for solving
programming problems.
lterative: The neural network is trained using given data. Once the training
is done, the weights are fixed. This method is based on the iterative update of
an input node toward a solution, while escaping from local minima. The
update rule is allowed to detect an input vector approaching a local mini
mum through a phenomenon called update explosion. At or near local
minima, the input vector is guided by an escaping trajectory generated based
on global information, which is predefined or known information on forward
mapping.
Error Backpropagat i on: This algorithm works by adjusting the weights
along the negative of the gradient in weight space of a standard error measure.
The standard error can be the leastmeansquareerror of the output. Using
what is essentially the same backpropagation scheme, one may instead com
pute the gradient of this error measure in the space of input activation vectors;
this gives rise to an algorithm for inverting the mapping performed by a net
work with specified weights. In this case the error is propagated back to the
input units and it is the activation of these units  rather than the values of the
weights in the network  that are adjusted so that a specified output pattern is
evoked. The inversion is not unique for given targets and depends on the
starting point in input space. The inversion tries to find an input pattern that
generates a specific output pattern with the existing connections. To find the
input, the deviation of each output from the desired output is computed as the
error 6. The error value is used to approach the target input in input space step
by step. The direction and length of this movement are computed by the in
version algorithm.
The most commonly used error value is the Least Mean Square Error. E LMs
is defined as
9
E LMs = Tp  f wijopi (8)
p=l
The goal of the algorithm, therefore, is to minimize E LMs . Since the error
signal 6pl can be computed as
6pi : Opi(l  Opi) Z 6pkWik (9)
kESucc(i)
and for the adaption value of the unit activation follows
S. Tejomurtula, S. Kak / Information Sciences 116 (1999) 147164 153
A netpi = rl6pi resp.netpi = netp/+ rl6pi. (10)
In this implementation, a uniform pattern is applied to the input units in the
first step, whose activation level depends upon the variable input pattern. This
pattern is propagated through the net and generates the initial output O (°). The
difference between the output vector and the target output vector is propagated
backwards through the net as error signal 61(0). This is analogous to propa
gation of error signals in backpropagation training, with the difference that no
weights are adjusted here. When the error signals reach the input layer, they
represent a gradient in the input space, which gives the direction for the gra
dient descent. Thereby, the new input vector can be computed as
i(1) = i(o) + ~/. 6~(o), (11)
where q is the step size in the input space. This procedure is now repeated with
the new input vector until the distance between the generated output vector
and the desired output vector falls below the predefined limit of 6m~x, when the
algorithm is halted.
4. Solving inverse kinematics with backpropagation
The inversion with the conventional errorbackpropagation algorithm is not
unique for given targets and depends on the starting point in input space.
Lu and Ito [2] proposed the use of subnetworks to obtain more than one
solution for a particular endeffector position. The configuration space was
divided into N regions in a uniform or nonuniform grid. The data points were
generated corresponding to each of the modular configuration spaces.
Fig. 2 shows a planar robot with three degrees of freedom [2] where the
workspace (locus of the endeffector) is in a single plane. The angle q3 is
marked negative because all the angles measured anticlockwise are positive.
The lengths of the arms taken for simulation purposes are:
Ll =0.3, L2=0.25 L3=0.15.
The joint variables are fixed to be in the following ranges.
ql E [z~/6, 2~/3], q2 E [0, 5r~/6], q3 E Ire/6, ~/6].
The forward kinematic equations of the model are as follows:
pt = LI cos(ql) + L2cos(ql + q2) + L3cos(ql + q2 + q3), (12)
P2 = L, sin (q~) + L2 sin(qt + q2) +L3 sin (q~ + q2 + q3). (13)
The configuration space is divided into eight overlapping regions via the grid
points (~/6, 3rc/12, 2rc/3), (0, 5~/12, 5~/6) and (~/6, 0, ~/6). For example,
the first region is described by intervals [re/6, 3rc/12], [0, 5zc/12], and In/6,0].
Table 1 shows the ranges of the coordinates of the workspace T~, T2,..., Ts.
154
s. Tejomurtula, S. Kak I hTformation Sciences 116 (1999) 1471~4
Fig. 2. A threejoint planar arm.
A neural network is trained with the backpropagat i on algorithm to learn the
forward mapping for each of the modul ar configuration spaces. The bound
aries of the workspace coordinates corresponding to each of the configuration
spaces is determined.
The endeffector position is given as the input. The modul ar networks (T~s)
with which the endeffector position can be reached are identified. The error
backpropagat i on algorithm is applied to each of those modul ar networks.
The initial guess for the errorbackpropagat i on is very critical for a speedy
convergence of the algorithm. Also the initial guess decides to which solution
the algorithm converges. A convenient way to obtain the initial guess is to train
a network with the endeffector positions as the inputs and joint variables as
the output. Corner classification was applied for the calculation of the initial
guess as it is much faster than the backpropagat i on algorithm.
A serious limitation of the backpropagat i on algorithm is the time involved
in training the network to learn the forward kinematics. The number of data
Table 1
An example of the ranges of the outputs in T~
T~ T_, 7"3 T4 7"5 7"6 /'7 T8
p]"~" 0.01 0.55 0.20 0.56 0.06 0.57 0.19 0.58
p~nax 0.70 0.53 0.61 0.18 0.70 0.53 0.59 0.02
p~i, 0.40 0.16 0.13 0.16 0.35 0,11 0.04 0.17
pT "x 0.60 0.70 0.57 0.58 0.60 0.69 0.52 0.59
S. Tejomurtula, S. Kak / hfolvnation Sciences 116 (1999) 147164
155
points for training cannot be reduced as accuracy is very critical in this ap
plication. Also forward kinematics can be determined for most of the existing
models of the manipulators. The forward kinematics cannot be determined for
some of the models having redundant joints. Even if the backpropagation
network learns all the data points fed, it cannot beat the accuracy of the for
ward kinematic equation.
5. A new network architecture for errorbackpropagation
Now we present our method which takes advantage of the fact that forward
kinematics can be determined for most of the manipultors.
Any conventional network for backpropagation has weights that are real
numbers. This network deviates from that common rule. The dimensions of the
workspace are trigonometric functions of the joint variables. So some of the
weights of the network are nonlinear relationships of the nodes between which
they are connected rather that real numbers. If there is a connection from node
i in hidden layer 1 to node j in hidden layer 2 and the weight is say cosine, the
value at node j in hidden layer 2 is cosine of the value at node i in hidden layer
1. Consider the example of the manipulator shown in Fig. 2. The position of
the endeffector is given by the following set of equations:
Pl = Ll cos (ql) + L2 cos (ql + q2) + L3 cOS (ql + q2 + q3),
(14)
P2 = Ll sin (ql) + Lz sin(ql + q2) + L3 sin(ql + q2 k q3),
(15)
where ql, q2 and q3 are the joint variables, p~ and p2 are the coordinates of the
endeffector, Lt,L2 and L3 are the lengths of the robot arms.
Instead of generating data of the joint variables and the Cartesian coordi
nates for training the network, the variables in the R.H.S of the equation i.e.,
L1, L2, L3, cos, sin are taken as the weights. The network architecture is as
shown in Fig. 3.
Unlike the conventional backpropagation algorithm, no training is re
quired for this network. This network is different in the sense that some of the
weights are nonlinear functions of the nodes between which they are con
nected. So the error in the output layer cannot be propagated back the usual
way.
5.1. The modified backpropagation
The neural network inversion for the errorbackpropagation algorithm
works as follows:
156
S. Tejomurtula, S. Kak / Information Sciences 116 (1999) 1471~4
HIDDEN HIDDEN
LAYER LAYER
I 2
qC)
k._J ~.~.~ ~ L 3
Fig. 3. Neural network representation of a threejoint planar arm.
hTput: The target point in the work space, range of each of the joint vari
ables.
Output: The final set of joint variables, within the proper ranges that make
the manipulator reach the target point.
A guess of the joint variables is made. The Cartesian coordinates of the end
effector position corresponding to the guessed point are calculated. The error in
each of the output neurons is determined. The error is propagated back the
usual way if the weight is of linear nature. If there is a nonlinear weight, a
decision is made whether the nonlinear function is an increasing or decreasing
function in the neighbourhood being considered. The error is propagated back
with the change of sign if the nonlinear function is decreasing. The error is
thus propagated back to the input layer and the input is adjusted. A check is
made whether the joint variables calculated are within the ranges set. If any
joint variable goes beyond its range, the value is clipped to the maximum or
minimum depending on the direction the deviation took place. The forward
calculation is performed. The process is repeated until the RMS value of the
error falls below a threshold. The final updated value of the input joint angles is
S. Tejomurtula, S. Kak I Information Sciences 116 (1999) 147164
157
the desired result. The algorithm limits the final result to the subrange in which
the guess is made. This algorithm does not require any extensive forward
training as a backpropagation algorithm. It also does not have any encoding
necessary as it takes in real values.
5.2. Modular networks
The partitioning of the joint space is done to get more than one solution, the
forward kinematics of the model involve cosine and sine of the angles ql, ql +
q2 and ql + q2 + q3. Since both the functions are decreasing or increasing de
pending on the value of the angle, the way the error needs be propagated from
hidden layer 2 to hidden layer 1 (Fig. 3) depends on whether the cosine/sine is
increasing or decreasing. The cosine or the sine of any angle changes sign at
every integer multiple of n/2. So within the ranges of the angles qt, ql + q2, and
ql + q2 + q3, the ranges are divided into smaller intervals with boundaries at
the multiples of n/2. The point to which the algorithm converges depends on
the initial guess. In order to evaluate the solutions for an endeffector position
within the range of the angles, a guess is made for each of the increasing/de
creasing trend regions. The set of guesses is calculated as follows. In the model
being considered, ql E [n/6,2n/3]. There are two multiples of n/2 in the
range. So the range is subdivided into [  n/6, 0], [0, n/2], [2n/3]. Similarly, the
ranges ofql + q2 is divided into [n/6, 0], [0, n/2], [n/2, n], [n, 3n/2]. The ranges
of ql + q2 + q3 are In~3, 0], [0, n/2], [n/2, hi, [n, 3n/2], [3n/2, 5n/3]. n guess is
a set of angles for qt, q2, q3. The guesses are made in such a way that all the
angle ranges for qt, q~ + q2, qt + q2 + q3 are covered.
The ranges of the coordinates of the workspace (T~s) are calculated. An end
effector position is the input. All the subnets T~ within which the point lies are
identified. It means that there may be zero, one or more solutions in this range.
The other T~'s are ruled out. There may not be a solution in each of the sub
ranges.
6. Results with robots of different degrees of freedom and different types of joints
The algorithm was applied on different models of the manipulator. It could
produce the solutions to a good degree of accuracy. The models and some of
the results are as follows. The results for the remaining models can be obtained
from [16].
6.1.. A planar robot with three degrees of freedom
The algorithm was applied to evaluate the inverse kinematic solutions of a
planar robot with three degrees of freedom shown in Fig. 2. The accuracy of
158
s. Tejomurtula, S. Kak / Information Sciences 116 (1999) 14716~I
the sol ut i on, i.e., the RMS di st ance between the cal cul at ed posi t i on of the
endeffector and the posi t i on of the t arget is of the order of 0.00000001.
Tabl e 2 shows the inverse ki nemat i c sol ut i ons for different endeffector po
sitions.
6.2. A robot arm with three degreesoffreedom and threedimentional workspace
These are the results of a r obot arm with three revol ut e j oi nt s and three
di ment i onal wor kspace [13]. Fig. 4 shows the t hreej oi nt arm. The same
length of the arms and the same range of the angles are t aken as in the
previ ous section. The forward ki nemat i c equat i ons for this model are as
follows.
Pl = Lt cos (ql)  Lzcos (q2)sin (ql)  L3 cos (q2 + q3)sin (ql), (16)
P2  L2 sin (q2) +L3si n(q2 + q3), (17)
P3 = Lt sin(q1) +L2cos( qz) cos( ql ) + Lacos (q2 + q3)cos(ql ). (18)
Unl i ke the previ ous model, the forward ki nemat i cs of this model involves
terms with product s of t ri gonomet ri c terms. So nodes for mul t i pl i ers are in
t roduced in the net work in hi dden layers as shown in Fig. 5. Redundant nodes
for mul t i pl i ers are i nt roduced in the third hi dden layer to keep a uni form
connect i vi t y bet ween successive layers, i.e., there is no direct connect i on from
Table 2
The inverse kinematic solutions for different endeffector positions for a planar robot
Endeffector qt q2 q3 pl p,.
position
1 60.36 51.23 77.76 60.36 60.36
1 0.523598561 0.389823676 0.523598776 0.6263140 0.2750000
1 0.523598720 0.000000000 0.523598586 0.6263140 0.2750000
2 0.283428164 2.455173741 0.012157724 0.0792008 0.2424363
2 0.283392003 2.450629821 0.000000000 0.0792008 0.2424363
2 0.349065961 2.617993632 0.523598776 0.0792008 0.2424363
2 0.349065822 2.228169666 0.523598776 0.0792008 0.2424363
3 1.221730545 2.617993792 0.523598776 0.1402081 0.0197430
4 1.622054081 1.862576405 0.239394981 0.4000000 0.2000000
4 1.612918914 1.780666961 0.000000000 0.4000000 0.2000000
4 1.656258942 1.938520345 0.523598776 0.4000000 0.2000000
4 1.621655383 1.685614178 0.234101156 0.4000000 0.2000000
4 1.656258947 1.548696341 0.523598776 0.4000000 0.2000000
5 1.101737701 0.144655985 0.000000000 0.2631111 0.6467348
5 1.178490703 0.083498632 0.195153053 0.2631111 0.6467348
5 1.126387962 0.049447955 0.139242221 0.2631111 0.6467348
S. Tejomurtula, S. Kak I Information Sciences 116 (1999) 147164
159
//////////
t
M.,,' q2
I
I
y
L I
y
I
L 2 ~rJq3 ['3
////////
Fig. 4. A threejoint arm.
hidden layer 2 to the output layer. The error is propagated in the usual way
from the output layer to the third hidden layer. At each multiplier node, the
error is propagated back equally on all the incoming links to the node. The
results are as shown in Table 3.
Since the ranges of the joint angles are fixed in advance, the algorithm
evaluates only those solutions that are within the reach with these angle ranges.
Some endeffector positions may have more solutions and some may have
fewer solutions. This is evident from the number of solutions of the first end
effector position and the second endeffector position.
7. Comparison between the different methods for solving inverse kinematics using
neural networks
The two methods commonly used for manipulator kinematic approximation
are multilayered networks with error backpropagation learning and Kohonen
maps [5]. These approaches are based on computational algorithms that can be
used only after a lengthy and computationally intensive optimization of the
160 S. Tejomurtula, S. Kak I hzformation Sciences 116 (1999) 147164
HIDDEN HIDDEN
LAYER I I~'~:~R 2
0 a.
HIDDEN
LAYER 9
Fig. 5. Neural network representation of a threejoint arm.
network internal weights (learning). Precision is the criterion considered for
comparison.
Consider an inverse kinematics problem for a threelink anthropomorphic
manipulator. The forward kinematic equations of the manipulator is given by
the following equations:
Pl = (L2 cos (q2) + L3 cos (q2 + q3)) cos (ql),
P2 = (L2 cos (q2) + L3 cos (q2 + q3)) sin (ql),
P3 = L1 + L2 sin(q2) + L3 sin(q2 + q3).
(19)
(20)
(21)
7.1. Multilayered perceptron network
In this method, the network nodes are organized in several layers. The most
common network design is with one or two hidden layers of nodes placed
between input and output layers. Sontag [15] proved that at least two hidden
layers are generally needed for inverse function approximation. The results
being shown are with two hidden layers. The goal is to minimize the mean
square approximation error between the predicted and actual points. The
S. Tejomurtula, S. Kak I Information Sciences 116 (1999) 147164 161
Table 3
The inverse kinematic solutions for different endeffector positions for a 3DOF robot and 3D
!
workspace
Endeffector ql q2 q3 Pl P2_ P3
position
1 0.523598776 0.064951571 0.523598776 0.46 0.05 0.19
2 0.523598776 0.766295849 0.523598776 0.43 0.21 0.14
2 0.523598776 0.708162701 0.375521399 0.43 0,21 0.14
2 0.523598776 0.388518064 0.488190808 0.43 0.21 0.14
2 0.523598776 0.564237030 0.000000000 0.43 0.21 0.14
2 0.523598776 0.467236633 0.263895837 0.43 0.21 0.14
3 0.523598776 1.530483942 0.384101928 0.30 0.38 0.09
3 0.523598776 1.358596344 0.000000000 0.30 0.38 0.09
4 0.008896367 0.279467795 0.272541291 0.30 0.07 0.38
4 0.000543558 0.377127807 0.523598776 0.30 0.07 0.38
4 0.011870896 0.175905768 0.000000000 0.30 0.07 0.38
4 0.007871382 0.245411662 0.183631824 0.30 0.07 0.38
4 0.001925112 0.000000000 0.492180134 0.30 0.07 0.38
4 0.004724206 0.058025595 0.349997378 0.30 0.07 0.38
5 0.521204783 1.557290929 0.522638798 0.30 0.38 0.08
5 0.521204783 !.369091525 0.000924961 0.30 0 0.08
limitation with this approach is that for more neurons the learning process
does not converge in a reasonable time. The experiments were conducted with
two hidden layers. There were 15 neurons in each of the hidden layers (see
Fig. 6).
7.2. Kohonen maps
Kohonen's selforganizing mapping algorithm is one of the most popular in
robotics application [3]. The Kohonen Map network consists of L nodes
(neurons) with a vector z~ E R k, a vector tp~ E R M, and a gradient matrix W~ E
R M×K associated with each node r. Suppose that a vector x is input to the
network. The node s such that [i x zsi[ is minimal over all the nodes and ap
proximates the function
y, = it', + W,(x  z,) (22)
is calculated. The above approximation can be computed once the network
parameters zr, ~,., W~ are known. They can be determined by seeking to mini
mize the mean square approximation error for the training set. Let the demand
function be
N
D({zr}, {tpr}, { W~}) = (1/2)~']ly (')  p(U) ll ~ min, (23)
,u=l
162
S. Tejomurtula, S. Kak / Information Sciences 116 (1999) 147164
MLP: Multilayered Perceptron Network
KM: Kohonen Maps
I0
K.M
I0 ......................... " ..................
MLP
173v ......................................................................... : .........................................................................
e~
165 ....................................................................................................................................................
6 Neural Network With Nonlinear Weights
10
7
10
I0 I I0 2 I0
NUMBER OF TRAI NI NG POI NTS
Fig. 6. Test set joint space errors.
where fi(") denotes the network output when the input vector x 0') of the training
set pair {x("),y(")} is given as the input.
To find the optimum network parameters iterative minimization of the cost
function with the steepest descent method is used.
7.3. Neur al network with nonlinear weights
The limitations with both the approaches above is the time involved in the
forward training and the degree of error involved in the forward approxima
tion. Both these are overcome in our approach to the problem. The algorithm
presented in this paper has been applied to the above model.
Ll =0.3, L2=0.25, L3=0.15, qlE[rc/6,2rc/3],
q2 E [0, 5rc/6], q3 E [~/6, rc/6].
An accuracy (error in the joint variables) of the order of 0.000001 is ob
tained for this model (Fig. 6).
S. Tejomurtula, S. Kak / Information Sciences 116 (1999) 147164 163
Table 4
The inverse kinematic solutions for different endeffector positions of a threelink manipulator
q~ q2 q3 pl P2_ P3
0.785398122 1.309012396 0.104674842 0.062346 0.062346 0.689635
0.785398163 1.805810804 0.314177173 0.032776 0.032776 0.692658
0.785398163 2.356196362 0.523591635 0.227452 0.227452 0.515600
1.308984846 1.621695644 0.418871863 0.010674 0.039834 0.689635
1.308984876 1.309000023 0.418872691 0.010674 0.039834 0.689635
1.570796327 1.544005759 0.314157775 0.000000 0.056854 0.691276
1.570796327 1.308998440 0.314157757 0.000000 0.056854 0.691276
1.308992696 1.308999632 0.209431202 0.018779 0.070083 0.691276
8. Concluding remarks
In this paper, we considered the problem of inverse kinematics in robotics.
We have presented several methods for finding multiple solutions for a given
endeffector position (as in the example of Table 4). The joint space was di
vided into uniform grids. The conventional backpropagation algorithm was
used for forward training but this leads to several difficulties related to accu
racy.
We have devised a variant of the conventional errorbackpropagation al
gorithm that overcomes the disadvantages of backpropagation algorithm like
training time and accuracy. Real data can be fed to the algorithm. The network
does not need any training because network weights can be read off using
forward kinematic equations. It could be used for realtime models as it gen
erates multiple solutions with a very good accuracy.
The proposed variant of the errorbackpropagation algorithm could be used
with other types of joints. The choice of the initial guesses is an important
factor in determining the result. The joint angles are analysed and then the
guesses are decided. Then the algorithm is run for each of the guesses. This
gives results of the joint variables some of which are close to each other while
others are quite different. Any one of them could be taken to reach the desired
endeffector position.
References
[1] Anon, SAE Mathematical Formulae and Statistical Tables Book, Secondary Education
Authority, 1992.
[2] L.L. Bao, K. Ito, Regularization of inverse kinematics for redundant manipulators using
neural network inversions, in: Proceedings of the IEEE International Conference on Neural
Networks, 1995.
[3] A. Benard, D.L.C.V. Gael, L.T.J. Yves, Selforganizing feature maps and the travelling
salesman problem, Neural Networks 1 (1988).
164 S. Tejomurtula, S. Kak I h~formation Sciences 116 (1999) 147164
[4] J.J. Craig, Introduction to Robotics: Mechanisms and Controls, AddisonWesley, Reading,
MA, 1989.
[5] Dimitri, Gorinevsky, T.H. Connoly, Comparison of some neural network and scattered data
approximation: The inverse manipulator kinematics example, Neural Computation 6 (1994)
521542.
[6] J. Duffy, Analysis of Mechanisms and Robot Manipulators, Wiley, New York, 1980.
[7] R. Featherstone, Position and velocity transformation between robot endeffector coordinate
and joint angle, The International Journal of Robotics Research 2 (2) (1983) 3545.
[8] J.U. Korein, N.I. Balder, Techniques for generating the goaldirected motion of articulated
structures, IEEE Computer Graphics and Applications 2 (9) (1982) 7181.
[9] S. Lee, R.M. Kil, Inverse mapping of continuous functions using local and global information,
IEEE Transaction on Neural Networks 5 (1994)409423.
[10] G.C.S. Lee, Robot Arm Kinematics, Dynamics and Control, Computer 15 (12) (1982) 6279.
[11] A. Linden, J. Kindermann, Inverting of multilayer nets, IJCNN, 2 (1989).
[12] D. Manocha, J.F. Canny, Efficient inverse kinematics for general 6r manipulators, IEEE
Transactions on Robotics and Automation 10 (5) (1994) 648657.
[13] R.M. Murray, Z. Li, S.S. Shastry, A Mathematical Introduction to Robotic Manipulation,
CRC Press, Boca Raton, 1994.
[14] R.P. Paul, B. Shimano, G.E. Mayer, Kinematic control equations for simple manipulators,
IEEE Transactions on Systems, Man, and Cybernetics SMCII (6) (1981) 6672.
[15] E.D. Sontag, Feedback stabilization using twohidden layer nets, Rutgers Center for Systems
and Control, Rutgers University, New Brunswick, N J, 1990.
[16] Sreenivas Tejomurtula, Inverse kinematics in robotics using neural networks, M.S. Thesis,
Louisiana State University, December, 1997.
[17] W.E. Synder, Industrial Robots: Computer Interfacing and Control, PrenticeHall, New
York, 1985.
[18] D. Manocha, Y. Zhu, A fast algorithm and system for the inverse kinematics of general serial
manipulators, IEEE Conference on Robotics and Automation 94 (1994) 33483354.
Enter the password to open this PDF file:
File name:

File size:

Title:

Author:

Subject:

Keywords:

Creation Date:

Modification Date:

Creator:

PDF Producer:

PDF Version:

Page Count:

Preparing document for printing…
0%
Comments 0
Log in to post a comment