control en modo de deslizamiento con redes neuronales...
TRANSCRIPT
CONTROL EN MODO DE DESLIZAMIENTO
CON REDES NEURONALES
DE UN ROBOT MANIPULADOR MOVIDO
POR UN MOTOR DC DE IMÁN PERMANENTE
PONENTE: RAMON LEYVA GRASA
ALUMNO: PEDRO ORTEGA PAPASEIT
Índice
0.- Objetivo del proyecto .................................................................
1.- Descripción del sistema ..............................................................
1.1.- Subsistema mecánico ......................................................................................................
1.1.- Subsistema eléctrico ........................................................................................................
4
4
4
6
2.- Control en modo de deslizamiento .............................................
2.1- Conceptos teóricos ...........................................................................................................
2.1.1.- Sistemas de estructura variable ......................................................................................
2.1.2.- Control en modo de deslizamiento. Descripción del sistema de errores de estado ...........
2.1.3.- Control en modo de deslizamiento. Descripción analítica del vector de estado ...............
2.1.4.- Movimientos deslizantes en convertidores conmutados de potencia ................................
2.2- Control en modo de deslizamiento de robots manipuladores ..........................................
2.2.1.- Análisis de la condición de transversalidad ....................................................................
2.2.2.- Condición de invariancia. Obtención de ueq ..................................................................
2.2.3.- Definición de las regiones de deslizamiento ...................................................................
2.2.4.- Análisis de la dinámica ideal de deslizamiento ..............................................................
2.2.5.- Obtención de los puntos de equilibrio del sistema correspondientes
a la dinámica ideal de deslizamiento ..............................................................................
2.2.6.- Análisis de la estabilidad de los puntos de equilibrio ......................................................
2.2.7.- Análisis de las regiones de deslizamiento .......................................................................
2.2.8.- Diseño e implementación del control .............................................................................
2.2.8.1. Elección de las constantes de la superficie deslizante k2 y k3. ............................
2.2.8.2. Programa en ACSL simulador del control en modo de deslizamiento. ...............
2.2.8.3. Resultados de simulación. ..................................................................................
2.2.8.4. Conclusión. ..................................................................................................................
7
7
7
8
10
15
16
16
17
18
19
20
21
22
24
24
29
33
35
3.- Redes neuronales. Conceptos generales y criterio de elección
3.1. Introducción .....................................................................................................................
3.2. Redes neuronales: Concepto ............................................................................................
3.2.1.- Unidad de procesamiento: la neurona. ............................................................................
3.2.2.- Arquitectura de una red. .................................................................. .............................
3.3. Características del procesamiento neuronal ...................................................................
37
37
38
39
42
45
3.3.1.- Aprendizaje .................................................................. ................................................ 47
3.3.2.- Aplicaciones .................................................................. ...............................................
3.4. Clasificación de modelos .................................................................. ...............................
3.4.1.- modelos feedback .................................................................. ........................................
3.4.2.- modelos feedforward .................................................................. ...................................
3.4.2.1.- lineales .................................................................. ..........................................
3.4.2.2.- no lineales .................................................................. .....................................
3.4.2.2.1- Aprendizaje supervisado. Perceptrones multicapa .............................
3.4.2.2.2- Aprendizaje no supervisado. Kohonen ..............................................
49
49
50
51
51
51
52
52
4.- Perceptrones multicapa y su aplicación. ...................................
4.1. Regla Delta de aprendizaje para perceptrones multicapa ..............................................
4.2. Regla Delta generalizada de aprendizaje ........................................................................
4.3. Fase feedforward y Entrenamiento de propagación hacia atrás del error. ....................
4.3.1. Fase feedforward .............................................................................................................
4.3.2. Entrenamiento de propagación hacia atrás del error ........................................................
4.3.3. Errores de entrenamiento ................................................................................................
4.4. Factores de aprendizaje ...................................................................................................
4.4.1. Pesos iniciales .................................................................................................................
4.4.2. Ajuste de pesos acumulativo versus actualización por incrementos. .................................
4.4.3. Pendiente de la función de activación ..............................................................................
4.4.4. Constante de aprendizaje .................................................................................................
4.4.5. Método del momento .......................................................................................................
4.4.6. Número necesario de neuronas ocultas ............................................................................
4.5. Control en modo de deslizamiento con redes neuronales de robots manipuladores .......
4.5.1. Diseño del sistema con redes neuronales. ........................................................................
4.5.2. Programa de preentrenamiento de la Red Neuronal Emuladora. ......................................
4.5.3. Resultados del entrenamiento de la RNE. ........................................................................
4.5.4. Programa de entrenamiento de la Red Neuronal Controladora. ........................................
4.5.5. Resultados del entrenamiento de la RNC. ........................................................................
4.5.6. Resultados del control adaptativo final. ...........................................................................
53
53
61
65
65
66
70
72
74
75
76
77
78
80
83
83
85
97
105
116
118
5- Conclusiones ................................................................................
6.- Bibliografía. ................................................................................
120
121
0. Objetivo del proyecto
El objetivo del proyecto es realizar el control de posición de un robot
manipulador movido por un motor que maneja cargas entre 0,1 y 0,5 kg.
En una primera fase se implementa un control en modo de deslizamiento en el
que se utiliza como superficie una combinación lineal de los estados medibles del
motor. Esta superficie reduce el orden de la planta y presenta resultados correctos en
régimen estacionario. Sin embargo, en régimen transitorio presenta una dinámica no
lineal dependiente del valor de la carga. Para abordar los problemas de parámetros
inciertos y no linealidad se usan redes neuronales capaces de aprender el
comportamiento de la planta y actuar en consecuencia. Los resultados de la simulación
muestran que la combinación de redes neuronales y de un control sliding puede
proporcionar una buena respuesta dinámica incluso ante grandes variaciones de la masa
de carga y/o la posición angular deseada.
1.- Descripción del sistema
La dinámica de muchos sistemas electromecánicos puede expresarse según tres
partes diferentes:
(i) un subsistema del comportamiento mecánico que incluye el motor y un
robot manipulador de articulación única.
(ii) un subsistema del comportamiento eléctrico que recoge los efectos
eléctricos más relevantes.
(iii) una relación estática que describe la conversión electromecánica.
1.1. Subsistema mecánico
En la figura 1.1 se muestra el esquema de un motor de corriente continua de
imán permanente y un robot manipulador acoplado en su rotor. La dinámica del
subsistema mecánico de la planta electromecánica modelada se puede aproximar por la
siguiente función:
M q D q N q i⋅ + ⋅ + ⋅ =•• •
sen( ) (1.1)
donde q(t) es la posición angular del brazo manipulador y de la carga.
Los parámetros M, N y D vienen dados por las siguientes ecuaciones:
MJ
K
m L
K
M L
K
M R
K
Nm L G
K
M L G
K
DD
K
= +⋅⋅
+⋅
+⋅ ⋅
⋅
=⋅ ⋅⋅
+⋅ ⋅
=
τ τ τ τ
τ τ
τ
02
0 02
0 02
0 0 0
0
3
2
5
2
(1.2)
(1.3)
(1.4)
donde J es la inercia del rótor, m es la masa de unión, M0 es la masa de carga,
L0 es la longitud de la unión, R0 es el radio de la carga, G es el coeficiente de gravedad,
D0 es el coeficiente de fricción viscosa en la articulación, i(t) es la corriente de
armadura del motor, y K τ es el coeficiente de conversión electromecánica de corriente
de armadura a par.
Figura 1.1: Descripción del sistema electromecánico.
Hay que remarcar que los parámetros M y N dependen de la masa de carga M0
y que existe una relación no lineal entre la corriente de armadura i y la posición angular
q.
1.2. Subsistema eléctrico
La dinámica del subsistema eléctrico del motor DC será:
L i V R i K qL B⋅ ′ = − ⋅ − ⋅• (1.5)
donde L es la inductancia de armadura, R representa las pérdidas óhmicas de la
armadura, KB es el coeficiente de la fuerza contraelectromotriz y VL es la tensión de
entrada.
Las ecuaciones (1.3) y (1.5) pueden ser expresadas de forma compacta como
sigue:
x f x B u•
= + ⋅( )(1.6)
donde
f x
RL
xK
Lx
Mx
DM
xNM
x
x
B
( ) sen( )=
− ⋅ − ⋅
⋅ − ⋅ − ⋅
1 2
1 2 3
2
1
B
V
LL
=
0
0
(1.7)
y u es la variable de control.
Figura 1.2: Modelo con fuentes controladas
2. Control en modo de deslizamiento
2.1. Conceptos teóricos
La teoría de sistemas de estructura variable y el control en modo de
deslizamiento son técnicas en el dominio del tiempo. El control en modo de
deslizamiento usa realimentación multiestado, y coloca directamente la respuesta
deseada en lazo cerrado en el dominio del tiempo.
2.1.1.- Sistemas de estructura variable
Los sistemas de estructura variable se caracterizan por una topología variante
en el tiempo, y como resultado la acción de control es discontinua y la planta no lineal.
En los convertidores conmutados la acción de control es discontinua y entran dentro de
la categoría de sistemas de estructura variable. Los convertidores más elementales
(reductor, elevador y reductor-elevador) pueden ser descritos de la siguiente manera:
x A x B
x A x B
•
•
= ⋅ + =
= ⋅ + =
1 1
2 2
1
0
para u
para u
(2.1)
(2.2)
donde xi
v=
De forma compacta
[ ]
x A x B u A x B u
A x B A A x u B B u
A x B A A x B B u
•
= ⋅ + ⋅ + ⋅ + ⋅ − == ⋅ + + − ⋅ ⋅ + − ⋅ =
= ⋅ + + − ⋅ + − ⋅
( ) ( ) ( )
( ) ( )
( ) ( )
1 1 2 2
2 2 1 2 1 2
2 2 1 2 1 2
1
(2.3)
Definiendo
A A
B
B A A
B B
:
=== −= −
2
2
1 2
1 2
δ
γ
(2.4)
tenemos la siguiente descripción bilineal
x A x B x u•
= ⋅ + + ⋅ + ⋅( ) ( )δ γ (2.5)
En un convertidor de orden n
x
x
x n
=
1
M , la dimensión es n × 1 ( )x n×1
y el resto de matrices son A n n n n n n× × × ×, , B y δ γ1 1
El objetivo final es sintetizar el control discontinuo u para conseguir que se
cumplan las especificaciones del convertidor.
2.1.2.- Control en modo de deslizamiento. Descripción del sistema de
errores de estado
La asignación de estado a un sistema no es única.
Si usamos como variables de estado los voltajes de los condensadores y las
corrientes de inductores, tenemos
x A x B x u•
= ⋅ + + ⋅ + ⋅δ γ( ) (2.6)
donde x n×1 es el vector de estado.
También podemos usar el error de voltage de salida ~v0 y sus derivadas
sucesivas. Definimos la matriz ~Vn×1
~
~~
~V
vdv
dt
d v
dt
n
n
n
×
−
−
=
1
0
0
10
1
M
~v v v
v
v
o o
o
o
0 = −≡
≡
*
*
voltaje de salida
salida deseada
El sistema correspondiente a la ecuación (2.6) puede también ser descrito de la
siguiente manera
~ ~V C V D u En n n n n n
•
× × × × ×= ⋅ + ⋅ +1 1 1 1 (2.7)
Una nueva ecuación puede ser construída como sigue
[ ]
S G V g v gdv
dtg
d v
dtG g g g
n
n
n
n
= ⋅ = ⋅ + ⋅ + ⋅ ⋅ ⋅ + ⋅ =
=
−
−
−
−
~ ~~ ~
, , ... ,
0 0 10
1
10
1
0 1 1
0
(2.8)
La nueva función S G V= ⋅ ~ es la suma ponderada del error de salida ~v0 y sus
sucesivas derivadas. Los elementos de la matriz G son las ganancias de realimentación
de ~v0 y sus derivadas. En geometría, la nueva ecuación S = 0 denota un hiperplano en
el espacio n-dimensional cuyos ejes son el error de salida y sus sucesivas derivadas.
El principio del control en modo de deslizamiento es restringir el sistema,
mediante una adecuada entrada de control, para permanecer en el hiperplano S = 0.
Cuando el sistema es restringido por control sliding para operar en el
hiperplano o superficie deslizante S = 0, resulta que la dinámica del sistema viene
dictada por
g v gdvdt
gd v
dtn
n
n0 0 10
1
10
1 0⋅ + ⋅ + ⋅⋅ ⋅ + ⋅ =−
−
−~
~ ~
(2.9)
Para forzar a los estados del sistema a que satisfagan S = 0, debe asumirse que
el sistema es capaz de alcanzar el estado S = 0 desde cualquier condición inicial y,
habiendo obtenido S = 0, que la acción de control es capaz de mantener el sistema en
S = 0. Estas condiciones pueden ser expresadas matemáticamente como
dSdt
dSdt
< > > <0 0 0 0 cuando S y cuando S
Cuando el estado del sistema está lejos de la superficie denotada por S = 0, la
dinámica de estado del sistema con respecto al tiempo dsdt
hace que el sistema se
dirija hacia la superficie S = 0. Así pues la entrada discontinua de control u debe ser
escogida de manera que las condiciones previas sean satisfechas.
Si asumimos que
u u S
u u S
= >
= <
+
−
cuando
cuando
0
0(2.10)
Combinando las ecuaciones (2.7) y (2.8) la siguiente relación puede ser
deducida para cumplir la condición de existencia
dSdt
G V G C V G D u G E
u u SdSdt
C V G D u G E
= ⋅ = ⋅ ⋅ + ⋅ ⋅ + ⋅
= > ⇒ < ⇒ ⋅ ⋅ + ⋅ ⋅ + ⋅ <
•
+ +
~ ~
~ cuando G0 0 0
(2.11)
(2.12)
u u SdSdt
C V G D u G E
G C V G D u G E G C V G D u G E
= < ⇒ > ⇒ ⋅ ⋅ + ⋅ ⋅ + ⋅ >
⋅ ⋅ + ⋅ ⋅ + ⋅ < < ⋅ ⋅ + ⋅ ⋅ + ⋅
− −
+ −
cuando G0 0 0
0
~
~ ~
(2.13)
(2.14)
Esta es la estrategia de control. Si la entrada de control u es escogida
apropiadamente para ser 1 o 0 de acuerdo con la ecuación (2.14), las características
dinámicas del sistema serán descritas mediante S = 0, o mediante las ganancias de
realimentación g0 1, , ... , g siendo independientes de otros parámetros del sistema. Esta
cualidad del control en modo de deslizamiento se denomina robustez.
2.1.3.- Control en modo de deslizamiento. Descripción analítica del vector
de estado
El estado del sistema es tomado como un vector x en ℜn con componentes
representando corrientes de inductor y voltajes de condensador.
Consideremos la representación bilineal de un convertidor continua-continua
x A x B x u f t x u
donde x
x
x n
•
= ⋅ + + ⋅ + ⋅ =
=
( ) ( ) ( , , )δ γ
1
M M y f =
f
f
1
n
(2.16)
(2.17)
El objetivo habitual en los circuitos convertidores de potencia continua-
continua es obtener una de las variables de estado, llamada x i , como una cantidad
constante. Se puede enfocar este objetivo de diseño como la inducción de un régimen
deslizante en la superficie
S x x K constanteni= ∈ℜ = − = = : S K 0; (2.18)
Una dinámica de deslizamiento existe siempre que x pueda ser conducida a
alcanzar S y después ser restringida para desenvolverse en esa superficie gracias al
cambio activo de la posición del conmutador. La posibilidad de alcanzar la superficie
deslizante debe ser cumplida mediante oportunas conmutaciones. Las posiciones del
conmutador se representan con u+ − y u . Entonces la condición necesaria y suficiente
para lograr el alcance local de la superficie viene dada por
Slim S f
Slim S f→
⟨∇ ⟩ <
→⟨∇ ⟩ >
+
+
−
−
00
00
,
,
(2.19)
(2.20)
donde ∇S es el gradiente de superficie, ⟨⟩ denota producto escalar y
f f t x u
f f t x u
+ +
− −
=
=
( , , )
( , , )
(2.21)
(2.22)
Figura 2.1: Proyecciones de los vectores de campo sobre el gradiente de
superficie.
Existe un modo deslizante si las proyecciones de los vectores de campo
f f t x u f t x u+ + − −= =( , , ) ( , , ) y f sobre el gradiente de superficie ∇S son de signo
opuesto y apuntan hacia la superficie.
La dinámica ideal del deslizamiento se caracteriza por tanto por las
condiciones de invariancia:
S
S f t x u eq
=⟨∇ ⟩ =
0
0, ( , , ) (2.23)
Las condiciones de invariancia expresan el hecho de que, idealmente, las
trayectorias de estado se desenvuelven en la superficie sliding sin ninguna proporción
de cambio en los valores coordinados de superficie, con respecto a las direcciones
definidas por el vector controlado de campo del sistema. La segunda condición en
(2.23) define el control equivalente como una ley de control de realimentación suave
que idealmente restringe las trayectorias de estado hacia S. Este control puede ser
obtenido como sigue
⟨∇ ⋅ + + ⋅ + ⋅ ⟩ =S A x B x u eq, ( ) ( )δ γ 0 (2.24)
Así pues
uS A xS B xeq = −
⟨∇ ⋅ + ⟩⟨∇ ⋅ + ⟩
,,
δγ
(2.25)
Una definición matemática rigurosa de la dinámica de deslizamiento es la dada
por Filippov, que lo explica como el movimiento resultante de la combinación particular
del vector controlado de campo, en ambos lados de la superficie, lo cual representa un
vector de campo tangente a la superficie deslizante.
Figura 2.2: Velocidad de fase en modo de deslizamiento.
La continuación del método de Filippov da el siguiente resultado: para
determinar la velocidad de fase en modo deslizamiento, en cada punto de la región
deslizante los vectores velocidad deben ser dibujados para los sistemas más alto y más
bajo y sus finales conectados.
Ya que el deslizamiento ideal ocurre en la superficie discontinua, el vector de
estado velocidad de ese movimiento está tendido en un plano tangencial a la superficie y
por lo tanto su final es el punto de intersección del plano tangencial y la línea recta que
conecta los finales de los vectores f + − y f .
Por tanto, la ecuación de deslizamiento ideal es de la forma:
x f x t
f f f
eq
eq
•
=
= ⋅ + − ⋅ ≤ ≤+ −
( , )
( )µ µ µ1 0 1
(2.26)
El número µ se interpreta como la fracción de tiempo en la cual el estado
permanece sobre la superficie. La cantidad (1-µ), por otro lado, representa la fracción
de tiempo en que la oscilación permanece por debajo de la superficie deslizante.
En nuestro caso los valores de control (0 o 1) implican:
x f f
A x B x A x B x
A x B x
•
= ⋅ + − ⋅ == ⋅ ⋅ + + ⋅ + ⋅ + − ⋅ ⋅ + + ⋅ + ⋅ == ⋅ + + ⋅ ⋅ +
+ −µ µµ δ γ µ δ γ
δ µ γ
( )
( ( ) ) ( ) ( ( ) )
( )
1
1 1 0 (2.27)
Por otro lado, la dinámica ideal de deslizamiento en la superficie S se
caracteriza por
x A x B x ueq
•
= ⋅ + + ⋅ + ⋅δ γ( ) (2.28)
Comparando (2.27) con (2.28) se advierte que la cantidad µ es precisamente el
control equivalente.
La interpretación de µ hecha por Filippov lleva inmediatamente a contemplar el
control equivalente como la proporción de servicio (duty ratio) usado habitualmente en
esquemas de control PWM (Modulación de anchura de pulsos). La cantidad (1-µ) es el
complementario del duty ratio.
Una condición necesaria para la existencia de un movimiento deslizante en S,
la existencia del control equivalente ueq, es representada por la condición de
transversalidad:
⟨∇ ⋅ + ⟩ ≠S B x, γ 0 (2.29)
la cual significa que B x⋅ + γ no puede ser tangente a la superficie discontinua.
La expresión (2.29) puede ser positiva o negativa.
Si consideramos u u+ −> , y teniendo en cuenta (2.19), (2.20) podemos
escribir
⟨∇ ⋅ + + ⋅ ⋅ + ⟩ <
⟨∇ ⋅ + + ⋅ ⋅ + ⟩ >
+
−
S A x u B x
S A x u B x
,( ) ( )
, ( ) ( )
δ γ
δ γ
0
0
(2.30)
(2.31)
Por consiguiente
⟨∇ − ⋅ + − ⋅ ⋅ + ⟩ <−S A x u B x, ( ) ( )δ γ 0 (2.32)
y
⟨∇ − ⋅ ⋅ + ⟩ <+ −S u u B x,( ) ( )γ 0 (2.33)
lo cual implica ⟨∇ ⋅ + ⟩ <S B x,( )γ 0 (2.34)
Por otro lado,
⟨∇ ⋅ + + ⋅ ⋅ + ⟩ =
⟨∇ ⋅ + + ⋅ ⋅ + ⟩ <+
S A x u B x
S A x u B x
eq, ( ) ( )
, ( ) ( )
δ γ
δ γ
0
0
(2.35)
(2.36)
Por consiguiente
⟨∇ − ⋅ ⋅ + ⟩ <+S u u B xeq, ( ) ( )γ 0 (2.37)
De (2.34) y (2.37) derivamos
u ueq+ − > 0 (2.38)
Similarmente
⟨∇ − ⋅ ⋅ + ⟩ >−S u u B xeq, ( ) ( )γ 0 (2.39)
lo que implica
u u eq− − < 0 (2.40)
Las inigualdades (2.38) y (2.40) pueden ser expresadas de forma compacta
u u ueq− +< < (2.41)
Siguiendo el mismo procedimiento obtenemos para u u− +>
⟨∇ ⋅ + ⟩ >S B x,( )γ 0
u ueq+ − < 0
u u eq− − > 0
(2.42)
(2.43)
(2.44)
Equivalentemente
u u ueq+ −< < (2.45)
Podemos compactar las expresiones (2.41) y (2.45) como sigue
max u u u min u ueq( , ) ( , )+ − + −> > (2.46)
Las regiones en el espacio de estado en las cuales una región sliding puede ser
creada son
R x S A x u B x
R x S A x u B x
n
n
++
−−
= ∈ℜ ∇ ⋅ + + ⋅ ⋅ + <
= ∈ℜ ∇ ⋅ + + ⋅ ⋅ + >
: , ( ) ( )
: , ( ) ( )
δ γ
δ γ
0
0
(2.47)
(2.48)
Un régimen sliding existe localmente en S si y solamente si
R R S+ −∩ ∩ es un conjunto no vacío
2.1.4.- Movimientos deslizantes en convertidores conmutados de potencia
Analizaremos las regiones en el espacio de estado en las que un régimen
sliding puede ser creado cuando la superficie se define como
S x x x K constanteni= ∈ℜ = − = = : S K ( ) 0 (2.49)
Procederemos como sigue:
i) Análisis de la condición de transversalidad.
ii) Obtención de ueq.
iii) Definición de las regiones sliding.
iv) Análisis de la dinámica sliding ideal
x A x u x B x
S x
x K
eq
i
•
= ⋅ + + ⋅ ⋅ +=
=
( ) ( ) ( )
( )
δ γ0
(2.50)
v) Obtención de los puntos de equilibrio del sistema correspondientes a la
dinámica sliding ideal.
vi) Análisis de la estabilidad de los puntos de equilibrio.
vii) Análisis de las regiones sliding.
viii) Implementación del control.
2.2. Control en modo de deslizamiento de robots manipuladores
El control sliding de brazos manipuladores es un tema bien conocido en el
campo de sistemas de estructura variable. Muchos controladores están basados en
superficies discontinuas no lineales o en superficies que incorporan parámetros del
sistema no mesurables. Se trata de sistemas que presentan un alto grado de complejidad.
En el caso opuesto se encuentran los controladores en modo deslizante basados en
superficies que conmutan. Estas superficies son combinaciones lineales invariantes en el
tiempo de los estados mesurables del sistema, y pueden ser fácilmente implementadas a
pesar de no ser eficientes en casos de parámetros inciertos y sistemas no lineales
variantes en el tiempo. Sin embargo, el uso de este control desemboca en una dinámica
estable de orden reducido.
Analizaremos las regiones en el espacio de estado en las que un régimen
sliding puede ser creado cuando la superficie se define como
S x x x( , , )1 2 3 0= (2.51)
Procederemos como sigue:
2.2.1. Análisis de la condición de transversalidad.
Esta condición requiere, según se vio en (2.29), que el producto escalar
siguiente sea no nulo:
∇ ≠S B, 0 (2.52)
donde ∇S es el gradiente de superficie y ⟨⟩ denota producto escalar. Realizamos la
operación producto escalar:
∂∂
∂∂
∂∂
∂∂
∂∂
∂∂
∂∂
Sx
Sx
Sx
V
LSx
V
LSx
Sx
Sx
V
LL L L
1 2 3 1 2 3 1
0 0 0 0, , , , ,
= ⋅ + ⋅ + ⋅ = ⋅
El resultado obtenido implica que ∂∂
S
x1
debe ser distinto de 0 para que pueda
realizarse correctamente un control deslizante.
∂∂
S
x1
0≠ (2.53)
Sin perder generalidad, se puede asumir que
∂∂
S
x1
1= (2.54)
entonces (2.51) resulta:
S x x x x S x x( , , ) ( , )1 2 3 1 1 2 3= + (2.55)
2.2.2. Condicion de invariancia. Obtencion de u eq
Así pues, el control equivalente vendrá expresado por
u xS A x
S B x
S f x
S Beq ( ),
,
, ( )
,= −
∇ ⋅ +∇ ⋅ +
= −∇
∇δγ (2.56)
El gradiente de S es ∇ =
S
S
x
S
x1 1
2
1
3
, ,∂∂
∂∂
El producto escalar del numerador es:
∇ =S f x, ( )
=
− ⋅ − ⋅ ⋅ − ⋅ − ⋅
=
= − ⋅ − ⋅ + ⋅ ⋅ − ⋅ − ⋅
− ⋅
11
1
1
2
1
31 2 1 2 3 2
1 21
21 2 3
1
32
, , , , sen( ),
sen( )
∂∂
∂∂
∂∂
∂∂
S
x
S
xRL
xK
Lx
Mx
DM
xNM
x x
RL
xK
Lx
S
x Mx
DM
xNM
xS
xx
B
B
El producto escalar del denominador es:
∇ =
=S BS
x
S
x
V
L
V
LL L, , , , , ,1 0 01
2
1
3
∂∂
∂∂
Así pues, el control equivalente resulta
u xL
VRL
xK
Lx
S
x Mx
DM
xNM
xS
xxeq
L
B( ) sen( )= ⋅ ⋅ + ⋅ + ⋅ − ⋅ + ⋅ + ⋅
− ⋅
1 2
1
21 2 3
1
32
1∂∂
∂∂
(2.57)
La ley de control vendrá expresada como
ux
x=
<− >
si S
si S
1 0
1 0
( )
( ) (2.58)
Esta ley de control puede implementarse mediante un puente de conmutación
SRC como se muestra en la figura 2.3
a)
b)
Figura 2.3:
a) Descripción general de la planta.
b) Modelo del puente de conmutación
SRC.
2.2.3. Definición de las regiones de deslizamiento.
Del apartado 2.1.3 tenemos que
⟨∇ + ⋅ ⟩ <+S f x B u, ( ) 0 (2.59)
Esta ecuación conduce a
( ) ( )( )
11
0 0 0
11
0
1
1
2
1
31 2 1 2 3 2
1 21
21 2 3
1
32
1 21
21 2 3
, , , , sen( ), , ,
sen( )
sen( )
∂∂
∂∂
∂∂
∂∂
∂∂
S
x
S
xRL
xK
Lx
Mx
DM
xNM
x x uV
L
RL
xK
Lx
V
L
S
x Mx
DM
xNM
xS
xx
RL
xK
Lx
S
x Mx
DM
xNM
x
B g
B g
B
− ⋅ − ⋅ ⋅ − ⋅ − ⋅ + ⋅
<
− ⋅ − ⋅ + − ⋅ + ⋅ ⋅ − ⋅ − ⋅
+ ⋅ <
⋅ + ⋅ − ⋅ ⋅ − ⋅ − ⋅
+ ⟩
− ⋅ <∂∂S
xx
V
Lg1
32
(2.60)
Similarmente
⟨∇ + ⋅ ⟩ >−S f x B u, ( ) 0 (2.61)
conduce a
( ) ( ) ( )11
0 0
10
1
1
2
1
31 2 1 2 3 2
1 21
21 2 3
1
32
1 21
21 2 3
1
32
, , , , sen( ), , ,
sen( )
sen( )
∂∂
∂∂
∂∂
∂∂
∂∂
∂∂
S
x
S
xRL
xK
Lx
Mx
DM
xNM
x x uV
L
RL
xK
Lx
V
L
S
x Mx
DM
xNM
xS
xx
RL
xK
Lx
S
x Mx
DM
xNM
xS
xx
B g
B g
B
− ⋅ − ⋅ ⋅ − ⋅ − ⋅ + ⋅ =
− ⋅ − ⋅ + + ⋅ ⋅ − ⋅ − ⋅
+ ⋅ >
⋅ + ⋅ − ⋅ ⋅ − ⋅ − ⋅
− ⋅
−
> −V
Lg
(2.62)
De forma compacta, las inigualdades (2.60) y (2.62) quedan
− < ⋅ + ⋅ − ⋅ ⋅ − ⋅ − ⋅
− ⋅ <V
LRL
xK
Lx
S
x Mx
DM
xNM
xS
xx
V
Lg B g
1 21
21 2 3
1
32
1∂∂
∂∂
sen( )(2.63)
2.2.4. Análisis de la dinámica ideal de deslizamiento
De (2.50) tenemos
( )x f x u x B
S x
x k x k x K
eq
•
= + ⋅=
+ ⋅ + ⋅ =
( )
( ) 0
1 2 2 3 3
(2.64)
x f x u x B
RL
xK
Lx
Mx
DM
xNM
x
x
LV
RL
xK
Lx
S
x Mx
DM
xNM
xS
xx
V
L
S
x Mx
DM
xNM
eq
B
L
B
L
•
= + ⋅ =
− ⋅ − ⋅
⋅ − ⋅ − ⋅
+
+ ⋅ ⋅ + ⋅ + ⋅ − ⋅ + ⋅ + ⋅
− ⋅
⋅
=
=
⋅ − ⋅ + ⋅ + ⋅
( ) ( ) sen( )
sen( )
sen(
1 2
1 2 3
2
1 21
21 2 3
1
32
1
21 2
1
10
0
1
∂∂
∂∂
∂∂
xS
xx
Mx
DM
xNM
x
x
31
32
1 2 3
2
1
)
sen( )
− ⋅
⋅ − ⋅ − ⋅
∂∂
(2.65)
Considerando como superficie conmutable una combinación lineal invariante
en el tiempo de los estados mesurables del sistema, podemos reescribir la ecuación
(2.55)
S x x x x S x x xS
xx
S
xx K x k x k x K( , , ) ( , )1 2 3 1 1 2 3 1
1
22
1
33 1 2 2 3 3 0= + = + ⋅ + ⋅ − = + ⋅ + ⋅ − =
∂∂
∂∂
(2.66)
Si despejamos x1 y sustimos su valor en la segunda ecuación de (2.65),
tenemos que el sistema queda reducido a uno de orden 2
x K k x k x x
x
k D
Mx
k
Mx
NM
xKM
x1 2 2 3 3
2
3
22
33 3
2
= − ⋅ − ⋅ ⇒
= −+
⋅ − ⋅ − ⋅ +
•
•
sen( )(2.67)
2.2.5. Obtención del punto de equilibrio del sistema correspondiente a la
dinámica ideal de deslizamiento.
Sustituyendo x x2 3 por & , se puede reescribir la primera ecuación de estado del
sistema obtenida en régimen ideal de deslizamiento (2.67) como una ecuación
diferencial de segundo orden:
( )d qdt
k D
Mdqdt
k
Mq
NM
qKM
2
22 3= −
+
⋅ − ⋅ − ⋅ +sen(2.68)
En el punto de equilibrio se considera el ángulo de giro q como una constante
q *. Por consiguiente, en equilibrio se tiene
q qdqdt
d qdt
= → = =* y 0 02
2
y la ecuación diferencial queda
( ) ( )0 33= − ⋅ − ⋅ + = ⋅ + ⋅
k
Mq
NM
qKM
k q N q* sen * ; * sen * K(2.69)
Si k NKkmax3
3
>> → ≈ q*
A partir de esta aproximación, para tener q q ref* = , se deberá escoger el
siguiente valor de K:
K k q qref ref= ⋅ → =3 q* (2.70)
2.2.6. Análisis de la estabilidad de los puntos de equilibrio.
Para realizar el análisis de la estabilidad debe linealizarse la ecuación
diferencial de la dinámica ideal de deslizamiento alrededor del punto de equilibrio. De
esta manera se obtiene el comportamiento del sistema ante perturbaciones.
( ) ( )g qd qdt
k D
Mdqdt
k
Mq
NM
qKM
= = −+
⋅ − ⋅ − ⋅ +2
22 3 sen
( ) ( ) ( ) ( )g q g qq q
dg q
dq q qq q≈
=+
=⋅ −
* **
(2.71)
( ) ( )g qq q
k
Mq
NM
qKM=
= − ⋅ − ⋅ +*
* sen *0 3
Sustituyendo el valor de K obtenido en (2.69) tenemos
( )g qq q=
=*
0(2.72)
Por otra parte
( ) ( ) ( ) ( ) ( )dg q
dq q qq q
k D
Md qdt
q qk N q
Mq q
KM=
⋅ − = −+
⋅ ⋅ − −+ ⋅
⋅ − + =
** *
cos **2
2
23 ∆
( ) ( ) ( )= −+
⋅−
−+ ⋅
⋅ − +
k D
M
d q q
dt
k N q
Mq q
KM
2 3* cos **
∆
(2.73)
La ecuación diferencial linealizada queda
( ) ( ) ( )d q
dt
k D
M
d q
dt
k N q
Mq
KM
2
22 3∆ ∆
∆∆
= −+
−+ ⋅
⋅ +
cos *
(2.74)
En el dominio de la Transformada de Laplace:
( ) ( ) ( ) ( ) ( )s Q s
k D
Ms Q s
k N q
MQ s
K s
M2 2 3⋅ = −
+
⋅ ⋅ −+ ⋅
⋅ +∆ ∆ ∆
∆cos *
( ) ( ) ( )∆
∆Q s s
k D
Ms
k N q
M
K s
M2 2 3+
+⋅ +
+ ⋅
=
cos *
Así pues, la función de transferencia salida-entrada (modelo de baja señal) es:
∆∆x s
K sM
sk D
Ms
k N x
M
3
2 2 3 3
1( )
( ) cos( )=
++
⋅ ++ ⋅
(2.75)
donde ∆x s3 ( ) y ∆K s( ) son las transformadas de Laplace de las pequeñas variaciones
de ∆x3 y ∆K alrededor de sus respectivos valores nominales.
Tratándose de un sistema de segundo orden, la estabilidad del sistema está
asegurada si se cumple que
k D
k N máx
2
3
> −
>
(2.76)
(2.77)
donde la última restricción tiene en cuenta cualquier posición angular.
2.2.7. Análisis de las regiones de deslizamiento.
Si analizamos la definición de las regiones de deslizamiento vista en el
apartado 2.2.3. en régimen estacionario ( x x3 3= *), tenemos que la inigualdad (2.63)
queda
− < ⋅ − ⋅ ⋅ − ⋅
<V
LRL
x kM
xNM
xV
Lg g
1 2 1 3
1sen( *)
(2.78)
puesto que x2 0= .
En régimen estacionario la superficie deslizante es cero. El valor de la
velocidad también es nulo, y por lo tanto la ecuación del deslizamiento (2.66) queda
0 1 3 3= + ⋅ −x k x K (2.79)
Sustituyendo K de esta ecuación por su valor hallado en (2.69), resulta que el
valor de x1 en régimen estacionario es
( )x N x1 3= ⋅ sen * (2.80)
Sustituyendo el valor de x1 en la inigualdad (2.78), tenemos
− <⋅
⋅ <V
LR N
Lx
V
Lg gsen( *)3
(2.81)
Así pues, para que exista control sliding debe cumplirse que
V R Ng max> ⋅ (2.82)
Ya que N max ≈ 2 5, A
rad, el valor de la tensión de alimentación deberá ser
Vg > 12 5, .
1
2.2.8. Diseño e implementación del control.
Los valores de los parámetros del sistema que se utilizan en los cálculos y la
simulación (reportados por D.M. Dawson) son:
J m m L
R N m srad
L
R K K N mAB
= × ⋅ = =
= = ⋅ ⋅ = ×
= = = ⋅
=
−
−
1625 10 0 506 0 305
0 023 0 01625 250 10
5 0 0 90
15
3 20
03
. . .
. . .
. ,
kg kg m
m D H
G = 9.81 ms
V V
0
2 g
Ω τ
2.2.8.1. Elección de las constantes de la superficie deslizante k y k 2 3
Como se vio anteriormente, si k N max3 >> el ángulo de giro en el punto de
equilibrio es q Kk
* ≈3
. De la ecuación (1.3) se obtiene el valor máximo de N, que se
tiene con el máximo valor en la masa de carga ( M0 0 5= , kg ). Este valor es
N kg m AN s
Aradmax = ⋅ ⋅ ⋅ +
⋅ ⋅⋅
=10 9
9 8 0 305 0 5062
0 5 2 5007962,, , , , ,
(2.83)
Se pueden simplificar las unidades a partir de la fórmula de la fuerza centrípeta
[ ]F N m a m r kg m radsc n= ⋅ = ⋅ ⋅ ⋅ ⋅
ω22
Se considera que el valor mínimo de k 3 tiene que ser de 10 veces N max para
poder despreciar el término ( )N q⋅cos * .
Por otra parte, si k D2 >> se puede despreciar el término D.
El valor de D es el siguiente
DDK
N m srad
N mA
A srad
= =⋅ ⋅ ⋅
⋅ = ⋅−
0
316 25 10
0 900 018055
τ
,
,,
(2.84)
Por tanto, si D ≥ 0 18, y k 3 25≥ , la función de transferencia (2.75) queda
simplificada como sigue:
2
∆∆x sK s
Ms M k s M k
31
2 12
13
( )( )
=+ ⋅ ⋅ + ⋅
−
− − (2.85)
El valor de M −1 es función de la masa de carga. Los valores extremos de M se
obtienen de la ecuación (1.2), sustituyendo M0 por sus valores mínimo y máximo. Así
pues, tenemos que
( )M M kg A srad0
2
0 5 0 071= = ⋅, ,
( )M M kg A srad0
2
0 1 0 0296= = ⋅, ,
Agrupando los valores en una inigualdad tenemos
0 071 0 0296, ,> >M (2.86)
y los valores de la inversa de M resultan
14 077 33 78521, ,> >−M (2.87)
Si K(s) es una función escalón de valor ( )K sk q
sref=
⋅3 como se apuntó en
(2.70), tenemos que la posición angular en el dominio transformado resulta
( )Q sQ
sM k
s M k s M kQ
s s sref ref= ⋅
⋅+ ⋅ ⋅ + ⋅
= ⋅
+ ⋅ ⋅ ⋅ +
−
− −
13
2 12
13
02
20 0
22ω
ξ ω ω (2.88)
siendo ω01
3= ⋅−M k y ξ = ⋅−k M
k2
1
32 (2.89)
ω0 es la frecuencia de resonancia y ξ es el grado de amortiguamiento.
En el dominio del tiempo, el ángulo es
( ) ( )q t q tref
t
de= −−
⋅ ⋅ +
− ⋅ ⋅
11
0
2
ξ ω
ξωsen Φ (2.90)
siendo ω ω ξd = ⋅ −021 y Φ =
−
−tg 121 ξ
ξ (2.91)
De la elección de los valores de k 2 3 y k dependerá el tipo de respuesta del
sistema ya que ξ ω y 0 dependen de estas constantes. Si ξ < 0 el sistema es inestable;
con ξ = 0, la respuesta sería oscilatoria pura y con ξ > 1 se produciría un
3
sobreamortiguamiento (con el consiguiente error en régimen estacionario). Así pues, el
valor de ξ deberá ser
0 1< ≤ξ (2.92)
Para el caso de respuesta subamortiguada ( )0 1< <ξ , hay una serie de
variables secundarias dependientes de ξ ω y 0 a tener en cuenta a la hora del diseño. Se
trata del sobreimpulso, el tiempo de subida y el tiempo de establecimiento.
El sobreimpulso es la máxima desviación de la posición respecto a la
referencia. Alcanza el máximo en td
= πω
y su valor es:
( )
( ) ( )
qd
e edπ
ω ξπ
π ξ
ξ ωπω
ξ π
ξ
= −
−⋅ + =
↑+
+ = − = −
− ⋅ ⋅−
⋅
−11
1
1
02
2
1
2
sen
sen sen
Φ
Φ Φ
Por tanto el sobreimpulso queda
sp e=−
⋅
−
ξ π
ξ1 2
(2.93)
El tiempo de subida es el que tarda la posición en alcanzar por primera vez la
posición de referencia. Su valor es
t rd
= − =
−−
⋅ −
−
πω
πξ
ξ
ω ξ
Φtg 1
2
02
1
1
(2.94)
El tiempo de establecimiento es el que tarda la posición del manipulador en
establecerse definitivamente con una diferencia inferior al 2% respecto a la posición de
referencia. Su valor es:
ts = ⋅ =⋅
4 4
0
τξ ω (2.95)
Interesa tener la referencia estable a la salida lo antes posible. Pero tratándose
de un manipulador, las oscilaciones y el sobreimpulso deben ser mínimos porque
podrían provocar la caída del objeto manipulado identificado como masa de carga. Los
objetivos de tener un mínimo sobreimpulso y tiempos de subida y establecimiento
4
mínimos son incompatibles, por lo que se elige como prioritario el referente al
sobreimpulso al ser más crítico.
Para el caso ξ = 1 (amortiguamiento crítico), el sobreimpulso es nulo y los
tiempos de subida y establecimiento son iguales.
Para el diseño, hay que tener en cuenta que el grado de amortiguamiento no es
fijo. Sus valores extremos se dan con los valores extremos de la masa de carga. Por
tanto, el máximo valor de ξ , que se considera 1 (sobreimpulso nulo), se producirá con
masa de carga 0,1 kg. Así pues, de (2.89) se tiene
ξ maxmaxk M
k= = ⋅ ⇒ = ⋅ =
↑=
−
12
2 2533 7852
1 72
25
21
32
3
k
k
,
,
Así pues, el mínimo valor de ξ será
ξ minmink M
k= ⋅ = ⋅ =
−2
1
321 72
214 077
250 6453, , ,
Con estos valores las respuestas al escalón unitario serían:
5
Figura 2.4: Respuesta a escalón unitario con k 2 1 72= , y k 3 25= .
a) Con masa de carga 0,5kg
b) Con masa de carga 0,1kg
En el caso de la figura 2.4a, tengo
sp = →0 0704 7 04%, , de error
t r = 0 15855, s
t s = 0 3304,
En el caso de la figura 2.4b
s tp r s= = =0 0 27, , y t s
Manteniendo los mismos grados de amortiguamiento (entre 0,6453 y 1), se
pueden mejorar los tiempos de subida y establecimiento aumentando la frecuencia de
resonancia. Esto se consigue con valores más elevados de k2 3 y k , y los resultados
pueden apreciarse en la figura 2.5:
6
Figura 2.5: Respuesta a escalón unitario con k 2 5 44= , y k 3 250= .
a) Con masa de carga 0,5kg
b) Con masa de carga 0,1kg
De la figura 2.5a, tenemos
sp = →0 0704 7 04%, , de error
t r = 0 05, s
t s = 0 1045,
De la figura 2.5b
s tp r s= = =0 0 08, , y t s
A continuación, la figura 2.6 ilustra un caso con menores grados de
amortiguamiento. Se aprecia que todas las prestaciones empeoran, por lo que nos
7
quedaremos con los valores de k 2 3 y k diseñados anteriormente. Con masa de carga
igual a 0,5 kg el grado de amortiguamiento es 0,3227 y con masa de carga 0,1 kg es de
0,5.
Figura 2.6: Respuesta a escalón unitario con k 2 0 86= , y k 3 25= .
a) Con masa de carga 0,5kg
b) Con masa de carga 0,1kg
2.2.8.2. Programa en ACSL simulador del control en modo de
deslizamiento
Para que el funcionamiento del control simule al que sería un control real, debe
añadirse un valor de histéresis ∆S , de manera que la evaluación de la superficie S se
produzca en +∆S si S está creciendo y en −∆S si S está decreciendo. De esto modo,
además, la evolución de S puede ser observada con mayor facilidad.
8
La posición angular de referencia es una serie de constantes entre − +2 2π π y
que se presentan a intervalos suficientes para que al manipulador le de tiempo de llegar
a la referencia.
La masa de carga es también una serie de constantes que van variando entre los
0,1kg y los 0,5kg.
Los valores de las constante del sliding utilizados en la simulación son
k 2 3 25= 1,72 y k = .
9
Program Motor con slidingInitial "-------Constantes de la planta" Constant J=1.625e-3,m0=0.506,Mo=0.434,Lo=0.305 Constant Ro=0.023,Bo=16.25e-3,L=25e-3,R=5 Constant Kt=0.9,Kb=0.9,G=9.8,Vg=15
M=J/Kt+m0*Lo*Lo/(3*Kt)+Mo*Lo*Lo/Kt+2*Mo*Ro*Ro/(5*Kt) N=m0*Lo*G/(2*Kt)+Mo*Lo*G/Kt B=Bo/Kt
"-------coeficientes del sliding" Constant a=10,dk=2 k2=1.77 k3=25
"------Coeficientes de las ecuaciones de estado" a11=-R/L a12=-Kb/L dimension b1(2) b1(1)=Vg/L $ b1(2)=-Vg/L
"-----Constantes de tiempo del filtro reconstructor y desalida"
Constant tau=10.0e-3,taus=40.0e-3
"-----Condiciones iniciales de las variables de estadocontinuas"
Constant iic=0,wic=0,qic=0,Kic=0
"-----Condicion inicial del comparador con histeresis" Integer p p=1 s=iic+k2*wic+k3*qic-Kic if(s.GT.dk) p=2
"-----Condiciones iniciales de las variables discretas delas NN"
Dini=Kic D=Dini Dp=Dini qp=qic qm=qic
"-----Constantes de la referencia variable" Constant As0=1 Ref=As0
End $ "de initial"
Dynamic
10
"-------Communication Interval" Cinterval Cint = 1.0e-3 "-------Termination Condition" Constant Tstp = 4 Termt(T .GE. Tstp)
Derivative
"-------Integration Algorithm and Step Size" Algorithm Ialg = 4 Nsteps Nstp = 1 Maxterval Maxt = 1.0e-3
"-------Variables auxiliares" M=J/Kt+m0*Lo*Lo/(3*Kt)+Mo*Lo*Lo/Kt+2*Mo*Ro*Ro/(5*Kt) N=m0*Lo*G/(2*Kt)+Mo*Lo*G/Kt
"-------Ecuaciones de estado" i=INTEG(a11*i+a12*w +b1(p),iic) w=INTEG((i-B*w-N*sin(q))/M ,wic) q=INTEG( w ,qic)
"-------Control" Ref= As0 Ka = k3*Ref K = REALPL(tau,Ka) s=i+k2*w+k3*q-K
qq=REALPL(taus,q)
"-------Cambios de subintervalo" SCHEDULE aOn .XN. s+dk SCHEDULE aOff .XP. s-dk
End $ " of Derivative "
Discrete aOn p=1End $ " of Discrete aOn"
Discrete aOff p=2End $ " of Discrete aOff"
End $ " of Dynamic "End $ " of Program "
11
'Fichero de comandos de ejecucion de simulacion con ACSL'
'---Parametros del sliding'SET k2=1.72 $ SET K3=25
'---Condiciones iniciales'SET qe =0 $ SET iic=0 $ SET wic=0SET qic=0 $ SET Kic=0
'----- Parametros de entrenamiento On line'
SET As0=0 $ SET Mo=0.1
ACTION 'var'=10,'val'=3.15,'loc'=As0ACTION 'var'=15,'val'=0.4,'loc'=MoACTION 'var'=20,'val'=6.3,'loc'=As0ACTION 'var'=25,'val'=0.3,'loc'=MoACTION 'var'=30,'val'=3.15,'loc'=As0ACTION 'var'=40,'val'=1,'loc'=As0ACTION 'var'=45,'val'=0.5,'loc'=MoACTION 'var'=50,'val'=4,'loc'=As0ACTION 'var'=55,'val'=0.1,'loc'=MoACTION 'var'=60,'val'=1,'loc'=As0ACTION 'var'=70,'val'=-2,'loc'=As0ACTION 'var'=75,'val'=0.5,'loc'=MoACTION 'var'=80,'val'=0,'loc'=As0ACTION 'var'=85,'val'=0.2,'loc'=MoACTION 'var'=90,'val'=-3.15,'loc'=As0ACTION 'var'=95,'val'=0.4,'loc'=MoACTION 'var'=100,'val'=-6.3,'loc'=As0ACTION 'var'=105,'val'=0.15,'loc'=MoACTION 'var'=110,'val'=-3.15,'loc'=As0ACTION 'var'=120,'val'=-6.15,'loc'=As0ACTION 'var'=130,'val'=-5,'loc'=As0ACTION 'var'=135,'val'=0.4,'loc'=MoACTION 'var'=140,'val'=-3,'loc'=As0ACTION 'var'=150,'val'=-3,'loc'=As0ACTION 'var'=155,'val'=0.5,'loc'=MoACTION 'var'=160,'val'=0,'loc'=As0ACTION 'var'=165,'val'=0.25,'loc'=MoACTION 'var'=170,'val'=3.15,'loc'=As0ACTION 'var'=180,'val'=6.3,'loc'=As0ACTION 'var'=185,'val'=0.4,'loc'=MoACTION 'var'=190,'val'=3.15,'loc'=As0
'---Parametros de simulacion'
SET Tstp=199.99SET Cint=0.1SET Ialg=4SET Nstp=1SET Maxt=1.0e-3
PREPAR T,Ref,q,Mo,K,woutput/NCIOUT = 10 t,Ref,q
12
2.2.8.3. Resultados de simulación
De la ejecución del programa en ACSL tenemos los siguientes resultados:
Figura 2.7: Respuesta del manipulador bajo variaciones
en la referencia y/o en la masa de carga.
Figura 2.8: Masa de carga.
13
Figura 2.9: Evolución de la superficie sliding.
Figura 2.10: Velocidad del posicionador.
14
Figura 2.11: Corriente de armadura (A) en régimen estacionario.
Figura 2.12: Variable de control u en régimen estacionario.
2.2.8.4. Conclusión
En la figura 2.7 puede apreciarse la evolución de la posición angular variando
la posición de referencia, con una masa de carga variable. Como se vio en el apartado
2.2.8.1., el grado de amortiguamiento es función de la masa de carga y de ahí que según
sea ésta se aprecien diferentes niveles de rebasamiento. Los sobreimpulsos que se
observan son los mínimos posibles con este control. Para algunas posiciones se aprecia
15
un pequeño error en régimen estacionario que se considera aceptable. Podría eliminarse
aumentando ω0 y manteniendo ξ (con otros valores de k2 3 y k , apartado 2.2.8.1.).
Teniendo en cuenta que K k q ref= ⋅3 es una constante, se intuye que podrían
mejorarse los tiempos de retardo y establecimiento y el sobreimpulso modelando una
señal K variante en el tiempo que pudiera adaptarse en función del estado actual del
posicionador y la posición de referencia deseada. Estas prestaciones pueden llegar a
lograrse utilizando una Red Neuronal Controladora que suministre en cada momento la
variable K más conveniente, como se verá en la sección 4.
3. Redes neuronales. Conceptos generales y criterio de elección
3.1 Introducción
Existe un número de problemas en ciencia e ingeniería que implican la
extracción de información a partir de datos complejos e inciertos. Para muchos de estos
problemas, las aproximaciones tradicionales resultan inadecuadas.
Las redes neuronales han constituído un centro focal de intensa actividad
durante los últimos años, dando lugar a una maduración de las primitivas ideas
desarrolladas en los años sesenta. El procesamiento de la información realizado por
estos sistemas es un tipo alternativo al que utilizan los actuales sistemas
computacionales, los cuales procesan instrucciones o realizan cálculos almacenados en
una memoria y manipulan datos de la misma. En las redes neuronales, en cambio, el
paradigma emula el modelo biológico de aprendizaje y computación, con una fuerte
base de procesamiento en paralelo, y estando confundidos en cada unidad de cálculo el
proceso y la memoria.
Figura 3.1: Flujo de información en el sistema nervioso
La principal cualidad de estos sistemas la constituye su adaptabilidad dinámica,
esto es, su capacidad para variar de comportamiento en situaciones cambiantes. Para
llegar a esto, usan técnicas como el aprendizaje, generalización o autoorganización.
Están inspirados en el modelo de la neurona biológica, usando unidades elementales de
procesamiento que mimetizan algunas de las características de las neuronas biológicas.
El comportamiento global de una red determina su capacidad para ensayar
hipótesis, detectar patrones estadísticos y regularidades o ajustar dinámicamente un
modelo implícito implementado en la misma arquitectura. Este comportamiento va más
allá de la suma de las potencialidades de las neuronas que la componen. El resultado es
la emergencia de propiedades nuevas que pertenecen al sistema como un todo.
Los modelos y algoritmos neuronales actuales pueden ser simulados en
ordenadores convencionales y, de hecho, ésta es la forma más común de emplear estas
técnicas. Sin embargo, alcanzan su máxima potencia cuando son implementadas en un
hardware específico: los neurocomputadores.
3.2 Redes neuronales: Concepto
La definición de red neuronal más comunmente aceptada entre las personas que
trabajan en este campo se debe a Robert Hetch-Nielsen. Una red neuronal se puede
definir como:
Sistema de computación que consta de un gran número de elementos simples,
muy interconectados, que procesan la información respondiendo dinámicamente frente
a unos estímulos externos.
Existen unos elementos comunes que van a aparecer en cualquier concepto de
red neuronal:
-Elementos individuales de procesamiento o neuronas.
-Arquitectura de la red, definida por el interconexionado de los elementos de
procesamiento.
Vamos, por tanto, a estudiar com más detalle estos dos componentes.
3.2.1. Unidad de procesamiento: la neurona
El componente mínimo de una red neuronal es una neurona o elemento de
procesamiento. Es un dispositivo muy simple que transforma (en su soma, o cuerpo
celular) varias señales de entrada (dendritas) en una única salida (axón). Las entradas
pueden proceder de otras neuronas o bien ser entradas a la red desde el exterior. La
salida, asimismo, puede transmitirse a otras neuronas o funcionar como señal de salida a
la red, en cuyo caso el comportamiento es ligeramente diferente en cuanto a las
funciones que se le aplican o el uso final que se hace de ella.
Figura 3.2: Diagrama esquemático de una neurona biológica
Las señales de entrada se encuentran moduladas por un factor, llamado peso,
que gradúa la importancia de la conexión existente entre la neurona receptora y el
emisor de la señal (generalmente otra neurona).
Una neurona es, en realidad, un procesador muy simple con una capacidad
limitada de cómputo, restringida a un conjunto elemental de instrucciones (sumas y
productos) y una memoria pequeña para almacenar pesos y activaciones.
En el caso más sencillo, la actividad de una unidad en un determinado instante
es sencillamente la suma de las actividades de las unidades con las que está conectada,
ponderadas por los pesos correspondientes. En las redes más elaboradas, la actividad
será alguna función compleja de las señales que recibe.
De forma general, la función computada en cada elemento de procesamiento se
puede dividir en varios pasos:
1.- Suma ponderada de sus entradas. El lugar de unión entre cada una de las
señales de entrada y la neurona se denomina sinapsis. Dichas sinapsis regulan la
cantidad de información útil recibida desde cada una de las conexiones.
La expresión matemática que describe la conversión de patrones de entrada en
señales de respuesta o salida se llama función de transferencia de la neurona, y se
expresa de la siguiente manera:
net w yk kj jj
J
= ⋅=∑
1
(3.1)
donde:
net k representa la suma correspondiente a la neurona k, es decir, la cantidad de
información total que llega a la neurona.
y j son las entradas a la neurona.
w kj es el peso sinóptico que pondera la conexión entre la neurona k y la
neurona j. El conjunto de los w kj extendido a toda la red, conocido como matriz de
pesos, es donde se almacena en última instancia el algoritmo que va a realizar la red
neuronal.
En la figura 3.3 vemos gráficamente la relación entre estos conceptos.
Figura 3.3. Modelo de neurona artificial
2.- Función de activación. Es la función aplicada a la entrada neta netk . Este
paso consiste en convertir dicha entrada neta en un nivel de activación para la neurona,
el cual es equivalente al nivel de excitación de una neurona biológica.
La función de activación, compara la entrada total con un umbral propio y
controla la activación de la neurona.
Este umbral es un valor característico para cada neurona, o puede ser global a
todo el sistema. Delimita la cantidad de estímulo necesaria para que el elemento de
procesamiento genere una salida. Con esta técnica se pretende emular el
comportamiento real del sistema nervioso humano, en el que una neurona puede estar
en dos únicos estados: activa o inhibida; esto es, 1 ó 0, dependiendo de la entrada total.
La función más elemental es la función escalón:
o f netUUk k
k
k
= =∀ >=∀ <
( )10 net net (3.2)
donde ok es la salida de la neurona k, y U es el umbral límite de activación.
Sin embargo, esta función presenta algunas limitaciones. La principal es que no
es derivable, ya que no es continua. Esto representa sin duda una dificultad
infranqueable para la aplicación de las transformaciones necesarias para introducir
corrección de errores mediante algoritmos de aprendizaje. Si consideramos una red
neuronal como un sistema dinámico que evoluciona en el tiempo, parece claro que para
describir su comportamiento necesitamos ecuaciones diferenciales que podamos
resolver.
Por ello, se usan otras, como la sigmoide (o función logística):
f net k nete k( ) =
+ − ⋅
11 λ
(3.3)
que muestra un comportamiento parecido, tomando también valores entre 0 y 1,
sin tener la discontinuidad de la función escalón.
No todas las redes neuronales utilizan una función sigmoide, pero las más
efectivas generalmente lo hacen.
En la figura 3.4 vemos ejemplos de estas funciones.
Figura 3.4. Funciones de transferencia: a) escalón, b) sigmoide
Utilizando estas funciones, determinaremos la salida de la neurona de la
siguiente manera:
of net net U
ier otro casokk k=
>
( ), ( ),
si f en cualqu0 (3.4)
La función de activación aplicada, junto a parámetros tales como λ y U ,
determinará distintos tipos de neuronas.
En cualquier caso, una neurona se reduce finalmente a un sumador. Esta
simpleza estructural es uno de los principales rasgos característicos de la teoría de redes
neuronales. Por otra parte, y debido a esta simplicidad, las propiedades emergentes
aparecen como resultado del comportamiento global del sistema, interrelacionando cada
elemento de procesamiento con un número relativamente elevado de otros elementos.
El funcionamiento general de un elemento de procesamiento o neurona se ve
gráficamente en la figura 3.5.
Figura 3.5. Elemento de procesamiento. Neurona
3.2.2. Arquitectura de una red
Para definir totalmente una red neuronal no basta con describir el
comportamiento individual de sus componentes (neuronas), sino que hay que
especificar, además, el interconexionado existente entre ellas. Éstas se agrupan en capas,
cada una de ellas con un conjunto de neuronas de número variable y comportamiento
similar, constituyendo varias capas una red neuronal.
Cada capa está conectada a la inmediata posterior total o parcialmente, excepto
la última capa, que constituye la salida total de la red neuronal. Existen tres tipos de
capas:
1.- Capa de entrada. El número y tipo de neuronas que constituyen esta capa,
depende de los datos de entrada al problema.
2.- Capas intermedias. Pueden ser más de una, dependiendo del tipo y
complejidad del problema que va a resolver la red. Mediante el tratamiento adecuado de
estas capas se consiguen las propiedades de generalización, extracción de características,
adaptabilidad, etc., que hacen muy interesante el trabajo de las redes neuronales.
3.- Capa de salida. El número de neuronas de esta capa depende del formato
esperado de salida de la red.
Las diferentes formas de distribuir, conectar e interrelacionar estos tres tipos de
capas, junto al tipo de neuronas que constituyen cada una de ellas, nos van a definir los
diferentes paradigmas de red existentes.
La arquitectura general de una red neuronal se muestra en la figura 3.6
Figura 3.6. Arquitectura de una red neuronal
En la operativa habitual de construcción y manejo de la red existen cuatro
pasos a seguir:
-Fase de conceptuación. Partiendo del problema que hay que resolver, se
comprueba que su solución natural se obtiene a través de una red neuronal, y se estudia
que modelo de red de los existentes se ajusta más al problema.
-Fase de diseño. Se determina la arquitectura de la red, el tipo de elemento de
procesamiento (función de transferencia) y el algoritmo de aprendizaje a utilizar.
-Implementación. Una red neuronal encargada de realizar una tarea deberá ser
entrenada para su correcta realización, es decir, la arquitectura y los valores de los pesos
sinápticos habrán de ser los adecuados para suministrar la respuesta correcta cuando se
le presenta una entrada determinada. Al proceso en el que se determina esa
configuración óptima se le denomina entrenamiento, y se realiza a través de la
presentación de ejemplos. Se le presentarán a la red una batería de ejemplos de entradas
asociadas con la correspondiente respuesta, y se modificarán paulatinamente los pesos
sinápticos para que cada vez sea menor la discrepancia promedio entre las respuestas de
la red y las correctas.
Esta fase está dividida, a su vez, en dos pasos:
1.- Se elige un conjunto de entrenamiento significativo, se selecciona el
entorno de desarrollo adecuado y se entrena a la red.
2.- Una vez que ha finalizado el proceso de entrenamiento, se comprueba que
su comportamiento es el esperado con un número determinado de casos de ejemplo.
-Mantenimiento. Se integra la red neuronal en el sistema de información donde
va a operar habitualmente. Se hace un seguimiento del funcionamiento con casos reales.
Estos cuatro pasos se realizan iterativamente hasta que la red neuronal trabaje
en el entorno de instalación tal y como se espera.
El conjunto de una o varias redes neuronales, con los interfaces con el medio
exterior (de entrada y salida), forman un sistema neuronal. En él pueden incluirse otros
subsistemas, que pueden no ser de tipo neuronal, como sucede en las redes expertas,
simbiosis entre un sistema experto y una red neuronal.
3.3 Características del procesamiento neuronal
Como hemos visto, las propiedades globales de las redes neuronales surgen de
la complicidad de los componentes individuales, muy sencillos si se consideran
aisladamente. Las propiedades que pueden resultar fundamentales para la resolución de
determinados problemas son, entre otras:
-Paralelismo masivo, lo que proporciona gran capacidad de cómputo. Una red
neuronal se fundamenta en unidades individuales, cada una de las cuales se encarga de
calcular una función elemental sin necesidad de cooperar con las demás. Esto ofrece una
importante ventaja frente al procesamiento secuencial, donde cada unidad de cálculo
debe ejecutarse después de que hayan acabado las anteriores.
-Memoria asociativa distribuída. Un dato no se encuentra en un único sitio,
sino repartido por toda la estructura.
-Tolerancia a fallos. El sistema no deja de funcionar aunque se estropeen una
serie de componentes: el sistema se degrada atenuadamente con una función de error
continua, sin rupturas totales.
-Tratamiento simultáneo de grandes cantidades de información.
-Reconstrucción de datos parciales. Los datos de entrada no necesitan ser
explicados rigurosamente. Cuando el conocimiento del problema no es total, resulta
imprescindible la capacidad de procesamiento a partir de información parcial.
-Aprendizaje. El sistema va modificando su comportamiento para ajustarlo a
los datos que se le van proporcionando. Es ésta la propiedad más llamativa y que más
aplicaciones potenciales va a crear. Proporciona a cualquier sistema unas características
de flexibilidad y adaptabilidad que son de gran interés en cualquier entorno.
De acuerdo con estas propiedades, las redes neuronales se presentan como una
herramienta adecuada para tratar cierto tipo de problemas que presenten un conjunto de
características comunes y diferenciadoras. Estos problemas pertenecen al campo de las
aplicaciones industriales y empresariales y se caracterizan por:
-Las tecnologías tradicionales no ofrecen una solución adecuada al problema
que se va a tratar.
-Los datos de entrada pueden ser incompletos, variables o aparecer sometidos a
ruido indeseable (por ejemplo, un nombre mal escrito).
-Se dispone de un gran número de datos que sirvan para entrenar a la red y
comprobar los resultados obtenidos durante la etapa de aprendizaje (supervisado o
autónomo).
-El proceso de razonamiento que lleva a la solución del problema es muy
complejo o bien desconocido: sólo se conoce la relación causa/efecto, pero no la
heurística de la solución. Esta aproximación de caja negra, si bien tiene la limitación de
no poder proporcionar explicaciones de cómo se ha llegado a la solución (a diferencia
de los sistemas expertos); ofrece, en cambio, la ventaja de no tener que modelar
cuantitativamente, sino sólo cualitativamente, el proceso del mundo real objeto de
estudio. Desde fechas muy recientes, el proceso interno de la red se está convirtiendo en
una caja transparente que permite construir teorías sobre el comportamiento de la
misma.
-No se dispone de los recursos y la experiencia necesarios, o bien la cantidad de
parámetros que influyen es muy alta o desconocida, como para establecer un conjunto
exacto y cerrado de reglas heurísticas.
De forma general, se puede decir que la característica fundamental de una red
neuronal la constituye el comportamiento global de la misma, por encima de lo que se
podía esperar de la suma de las propiedades de sus componentes. Estas nuevas
propiedades emergentes que surgen como resultado de procesos dinámicos de
autoorganización son las responsables de las características diferenciadoras del
procesamiento neuronal frente al mecanismo lineal.
3.3.1. Aprendizaje
Una de las principales características en una red neuronal es su capacidad de
aprendizaje, razón por la que vamos a profundizar en ella.
El aprendizaje permite que la red modifique su propia estructura (matriz de
pesos) adaptándola hasta conseguir un algoritmo de ejecución. Este algoritmo se
construye a partir de las características extraídas de los ejemplos con los que se realiza
el entrenamiento. Aquí convendría hacer una distinción entre el concepto de aprendizaje
y el de entrenamiento.
El aprendizaje consiste en hacer cambios en los pesos de las conexiones entre
las neuronas de la red hasta conseguir la respuesta deseada. Podemos decir que el
entrenamiento es el procedimiento por el cual la red aprende, y que el aprendizaje es el
resultado final de ese proceso, y también que el primero es un procedimiento externo a
la red, y el segundo, un procedimiento o actividad interna.
En estos sistemas, la información no se almacena en un emplazamiento físico
único, ya que, como hemos dicho, la capacidad de almacenamiento individual es muy
limitada. Por el contrario, la información aparece distribuída por toda la estructura de la
red, concentrándose en las uniones de los distintos elementos. Esta es la base del
procesamiento distribuído: las funciones proporcionadas en estos sistemas vienen dadas
por la globalidad del sistema, más que por la aportación individual de cada elemento.
Tipos de aprendizaje:
Supervisado. Cada ejemplo de entrenamiento consta de un par formado por las
entradas al sistema y la salida esperada para esas entradas. La red neuronal necesita un
supervisor que le diga cómo es de buena su respuesta frente al estímulo dado. En el caso
de que cometa alguna incorrección, tendrá lugar cierta modificación interna del sistema
tendente a mejorar su rendimiento.
No supervisado. En el aprendizaje sin supervisión, la respuesta deseada no es
conocida: así pues, información explícita del error no puede ser utilizada para mejorar el
comportamiento de la red. Ya que no se puede obtener información sobre la corrección
o incorrección de las respuestas, el aprendizaje debe producirse de algún modo
basándose en observaciones de respuestas a entradas sobre las que no tenemos ningún o
casi ningún conocimiento. Por ejemplo, el aprendizaje no supervisado puede ser
adecuado para encontrar la frontera entre clases de patrones de entrada distribuídos
como se muestra en la figura 2.20. En un caso favorable, como en la figura 2.20a, las
fronteras de los grupos pueden ser encontradas basadas en el amplio y representativo
muestreo de entradas. Adecuados mecanismos de autoadaptación de pesos tienen que
ser encajados en la red entrenada, porque no se pueden conseguir instrucciones externas
considerando particiones potenciales. Una posible regla de adaptación de la red es: Un
patrón añadido al grupo tiene que estar más cerca del centro del grupo que del centro de
cualquier otro grupo.
Los algoritmos de aprendizaje no supervisado usan patrones que son
típicamente datos redundantes en bruto sin etiquetas en las que indique su pertenencia a
una clase, o asociaciones. En este modo de aprendizaje, la red debe descubrir por sí
misma cualquier posibles patrones existentes, regularidades, propiedades diferenciadas,
etc. Mientras las descubre, la red va cambiando sus parámetros, lo que se llama auto-
organización.
La técnica del aprendizaje no supervisado es a menudo usada para realizar
agrupamientos como la clasificación no supervisada de objetos sin proveer información
sobre las clases actuales. Este tipo de aprendizaje corresponde a mínima información
conseguible a priori. Alguna información sobre el número de grupos, o similitud contra
desimilitud de patrones, puede servir de ayuda para este modo de aprendizaje.
Finalmente, el aprendizaje a menudo no es posible en un entorno no supervisado, como
podría ser probablemente en el caso ilustrado en la figura 2.20b mostrando clases de
patrones difíciles de discernir incluso para un humano.
3.3.2. Aplicaciones
Existe un conjunto de aplicaciones en las que todas o alguna de estas
características aparecen. Las redes neuronales están siendo utilizadas para tratar tareas
que parecían inabordables por métodos tradicionales. Se trata de problemas que parecían
fáciles de resolver por un operador empleando capacidades innatas y de bajo nivel del
cerebro humano. Sin embargo, este tipo de problemas no han podido ser adecuadamente
tratados por los sofisticados sistemas informáticos actuales.
Dentro de este tipo de tareas, podemos encontrar:
-Sistemas de decisión
-Procesamiento de señales
-Lenguaje natural
-Visión
-Reconocimiento de texto escrito a mano e impreso
-Control en tiempo real
-Problemas np-completos
-Predicción de series temporales
-Clasificación de patrones
3.4. Clasificación de modelos
Existen varios modelos desarrollados a lo largo de la historia.
Los diferentes paradigmas van a venir determinados por las características
diferenciadoras que se enumeran a continuación:
-Tipo de neurona, que, a su vez, viene definida por:
-Tipos de entradas que admite: binarias o continuas.
-Valores de los parámetros de la función de transferencia.
-Tipo de la función de transferencia: lineal, sigmoide o tangente
hiperbólica.
-Distribución espacial de las neuronas, esto es, arquitectura de la red.
-Leyes de aprendizaje aplicadas: supervisado o no supervisado.
Veamos los más importantes y significativos paradigmas desarrollados hasta
ahora, clasificados según las características descritas anteriormente.
mod
mod
mod
sup
sup
elos deredes neuronales
elosfeedback
construidas
entrenadas
elosfeedforward
lineales perceptron
nolinealesaprendizaje ervisado perceptrones multicapa
aprendizaje no ervisado Kohonen
→
→
→
3.4.1. Modelos feedback
Se caracterizan por la conexión existente entre la salida de una neurona con su
entrada y la entrada del resto de las neuronas del sistema. De esta forma, la entrada de
una neurona en un instante de tiempo depende de los valores que ha tomado
anteriormente.
Las redes de este tipo pueden dividirse en dos grupos: construídas y entrenadas.
El primer grupo lo componen aquellas redes en las que la matriz de pesos
inicial se construye a partir de los patrones utilizados para definirla. Dentro de esta
clase, podemos destacar las memorias asociativas, entre las que se encuentran los
modelos de Hopfield, BAM, etc. Es importante destacar que a todos estos modelos se
puede asociar una función de energía, de forma que el proceso por el que la red llega a
una solución es equiparable a un proceso físico en el que el objetivo es la minimización
de la energía del sistema.
El segundo grupo incluye redes que para su definición necesitan un proceso de
entrenamiento. Dentro de este grupo se encuentran los modelos ART, que son
complejos debido a que el ajuste de pesos afecta a las señales de entrada durante el
proceso de aprendizaje.
3.4.2. Modelos feedforward
Este tipo de arquitecturas se caracterizan porque la salida de una neurona está
conectada a las entradas de otras neuronas, pero no a su propia entrada; es decir, los
impulsos se propagan en una única dirección.
Las arquitecturas feedforward actuales presentan un comportamiento
considerablemente mejor que las arquitecturas feedback, ya que requieren menor
capacidad de memoria y llegan más rápidamente a una solución una vez entrenadas.
A continuación, vamos a describir algunas de las arquitecturas feedforward más
importantes agrupándolas en diferentes clases, según su algoritmo de aprendizaje y el
tipo de modelo que describen: lineal o no lineal.
3.4.2.1. Lineales
Los modelos lineales son aquellos en que la salida de una neurona es una
función lineal de sus entradas. Aunque se ha demostrado que la mayor parte de los
problemas reales son demasiado complejos para ser resueltos con modelos lineales,
éstos son importantes, ya que los primeros modelos de redes neuronales utilizaban
funciones de transferencia lineales, y todos ellos son el punto de partida para los
modelos no lineales. (El Perceptrón de Rosenblatt)
3.4.2.2. No lineales
Los modelos no lineales surgieron como una solución a las restricciones que
aparecen en los modelos lineales. En éstos, la salida de una neurona es una función no
lineal de la suma de sus entradas. Los modelos que se describen a continuación son los
más utilizados en aplicaciones reales actualmente, y según su algoritmo de aprendizaje
los agrupamos en dos clases: aprendizaje supervisado y no supervisado.
3.4.2.2.1. Aprendizaje supervisado. Perceptrones multicapa
En los modelos que utilizan aprendizaje supervisado, durante la etapa de
entrenamiento se presentan a la red pares entrada/salida deseada que permiten a la red
ajustar los pesos de forma que se minimice el error obtenido. La minimización del error
se realiza propagando el error a través de la red. Esta forma de entrenamiento obliga al
sistema a retener la información que contienen los datos, de forma que la red pueda
generalizar correctamente su estructura.
Perceptrones multicapa
Es la arquitectura que mejores resultados proporciona y es la que utilizo en el
control. En el capítulo 4 se explica.
3.4.2.2.2. Aprendizaje no supervisado. Kohonen
En este tipo de aprendizaje se presenta a la red un conjunto de entradas para
que ella misma organice su estructura y realice su propia clasificación de las entradas,
este proceso se denomina clustering. La red debe aprender mediante mecanismos de
estímulo-reacción, de forma similar a como el ser humano aprende a hablar.
Este tipo de redes debe incorporar mecanismos de competición y de
cooperación entre las neuronas. La mayor parte de la investigación realizada sobre estos
esquemas de aprendizaje se basa en la aparición espontánea de detectores de
características.
En estos métodos se presenta una menor cantidad de información a la red, por
este motivo, siempre que dispongamos de la suficiente información, es preferible
utilizar un método supervisado que uno no supervisado. (Red de Kohonen)
4.- Perceptrones multicapa y su aplicación
El atributo más importante de una red multicapa feedforward es que puede
aprender mapeados de cualquier complejidad. La red entrenada suele producir
resultados sorprendentes y generalizaciones en aplicaciones en las que una derivación
explícita de mapeados y el descubrimiento de relaciones que resultaban ser una misión
imposible.
Además de las tareas de clasificación, muchas otras pueden realizarse con estas
redes. Por ejemplo, aproximación de funciones, reconocimiento de escritura manual,
reconocimiento de voz, control dinámico de plantas, cinemática de robots y generación
de trayectorias, sistemas expertos, y muchas otras aplicaciones.
La teoría de redes neuronales multicapa y aplicaciones han estado dominando
en la literatura de redes neuronales por muchos años. Se investiga sobre las propiedades
de las redes multicapa y sus métodos de entrenamiento.
Para entender la naturaleza del mapeado realizado por las redes multicapa
feedforward y su entrenamiento, debemos retornar a los fundamentos. En este capítulo
estudiaremos redes neuronales multicapa que emplean los principios del mapeado del
patrón de entradas. En el caso del entrenamiento de redes multicapa, veremos que el
error de mapeado puede ser propagado a las capas escondidas de manera que la
información del error de salida se propaga hacia atrás. Este mecanismo de transmisión
se usa para modificar los pesos sinápticos de todas las capas de neuronas. La regla delta
de aprendizaje y su generalización son usadas a lo largo del capítulo para el
entrenamiento supervisado de redes multicapa de perceptrones continuos.
4.1. Regla Delta de aprendizaje para perceptrones multicapa
La siguiente discusión está enfocada hacia la búsqueda de un algoritmo de
entrenamiento eficaz para las redes feedforward multicapa. El algoritmo se denomina
algoritmo de propagación hacia atrás del error. Este algoritmo animó a la comunidad
científica y de ingeniería al modelado de muchos fenómenos cuantitativos usando redes
neuronales.
El algoritmo de propagación hacia atrás del error permite la adquisición
experimental del conocimiento del mapeado de entrada/salida con redes multicapa. Los
patrones de entrada son sometidos secuencialmente durante el entrenamiento de
propagación hacia atrás. Cuando un patrón es presentado a la red y su clasificación o
asociación se determina como errónea, los pesos sinápticos y los umbrales (si existen)
son ajustados de manera que el error cuadrático sea reducido. El mapeado de
entrada/salida, la comparación de los valores actuales y los deseados, y el ajuste, si se
requiere, continúan hasta que todos los ejemplos de mapeado de la serie de
entrenamiento son aprendidos con un error aceptable.
Durante la fase de asociación o de clasificación, la red neuronal entrenada
opera por sí misma en modo feedforward. En la fase de backpropagation los ajustes de
los pesos forzados por las reglas de aprendizaje se propagan hacia atrás desde la capa de
salida a través de las llamadas capas escondidas hacia la capa de entrada.
figura 4.1: Red de dos capas con perceptrones continuos
En la figura 4.1, los valores de entrada y salida de la red son etiquetados como
y j k y o , respectivamente. Podemos, así pues, decir que y j , para j= 1 2, , ... , J , y ok ,
para k = 1 2, , ... , K son valores de señal en la columna j-ésima de nodos, y k-ésima
columna de nodos, respectivamente. El peso w kj conecta la salida de la neurona j-ésima
con la entrada de la neurona k-ésima.
Usando notación vectorial, el paso hacia delante (fase feedforward) en la red de
la figura 4.1 puede ser expresado como sigue
[ ]o W y= ⋅Γ (4.1a)
donde los vectores de entrada y salida y la matriz de pesos son, respectivamente
y
yy
y
o
oo
oJ K
=
=
1
2
1
2
! !, , W
w w ww w w
w w w
J
J
K K KJ
=
11 12 1
21 22 2
1 2
"
"
! ! " !
"
y el operador diagonal no lineal [ ]Γ ⋅ es
[ ]
( )( )
( )
Γ ⋅ =
⋅⋅
⋅
ff
f
0 00 0
0 0
"
"
! ! " !
"
El vector deseado de salida es
d
dd
d K
=
1
2
!
El vector de activación net k de la capa k está contenido en los corchetes en la
relación (4.1a) y puede ser expresado como
net W yk = ⋅ (4.1b)
La expresión del error generalizada para incluir todos los errores cuadráticos en
las salidas k = 1 2, , ... , K es
( )E d o d op pk pk p pk
K
= ⋅ − = ⋅ −=∑1
212
2 2
1
(4.2)
para un patrón específico p, donde p = 1 2, , ... , . P La p suscrita en (4.2) se refiere a un
patrón específico que está en la entrada y produce el error de salida. En este punto, la
regla delta de entrenamiento puede ser formalmente derivada para un perceptrón
multicapa. Vamos a asumir que la búsqueda por descenso de gradiente se realiza para
reducir el error E p a través del ajuste de pesos. Computamos el ajuste individual de
peso como sigue:
∆w Ewkj
kj
= − ⋅η ∂∂
(4.3a)
donde el error E es el definido en (4.2). Para cada nodo en la capa k, k = 1 2, , ... , K ,
podemos escribir usando (4.1b)
net w yk kj jj
J
= ⋅=∑
1
(4.3b)
y además, usando (4.1a) la salida de neurona es
( )o f netk k=
El término error de señal δ producido por la neurona k-ésima es definido para
esta capa como sigue
( )δ ∂∂ok
k
Enet
=−∆ (4.4)
Es obvio que el componente de gradiente ∂ ∂E w kj/ depende sólo del valor de
net k de una única neurona, ya que sólo los pesos w kj contribuyen al error a la salida de
la neurona k-ésima, para j= 1 2, , ... , J y el valor k fijado. Así pues, usando la regla de
la cadena podemos escribir
( )( )∂
∂∂
∂∂∂
Ew
Enet
netwkj k
k
kj
= ⋅(4.5)
El segundo término del producto de la ecuación (4.5) es la derivada de la suma
de productos de pesos y patrones w y w y w yk k kJ J1 1 2 2⋅ + ⋅ + ⋅ ⋅ ⋅ + ⋅ como se vio en
(4.3b). Ya que los valores y j , para j J= 1 2, , ... , , son constantes para un patrón fijado
en la entrada, obtenemos
( )∂∂netw
yk
kjj=
(4.6)
Combinando las ecuaciones (4.4) y (4.6) se llega a la siguiente forma de (4.5):
∂∂
δEw
ykj
ok j= − ⋅ (4.7)
La fórmula de ajuste de pesos (4.3a) puede ser ahora reescrita usando el
término error de señal δok como se ve a continuación:
∆w ykj ok j= ⋅ ⋅η δ , para k = =1 2 1 2, , ... , , , ... , K y j J (4.8)
La expresión (4.8) representa la fórmula general del ajuste de pesos del
entrenamiento/aprendizaje delta para una red de dos capas. Puede notarse que ∆w kj en
(4.8) no depende de la forma de la función de activación. El valor delta necesita ser
explícitamente computado para específicas funciones de activación escogidas. De (4.8)
sigue que el ajuste del peso w kj es proporcional a la activación de entrada y j , y al valor
del error de señal δok en la k-ésima neurona de salida.
Para adaptar los pesos, el término delta error de señal δok introducido en (4.4)
necesita ser computado por el k-ésimo perceptrón continuo. Hay que significar que E es
una función compuesta de net k , y por lo tanto puede ser expresada para
k = 1 2, , ... , K , como sigue:
( ) ( )[ ]E net E o netk k k= (4.9)
Así pues, tenemos desde (4.4)
( )δ ∂∂
∂∂ok
k
k
k
Eo
onet
= − ⋅(4.10)
Denotando el segundo término en (4.10) como una derivada de la función de
activación
( ) ( )f neto
netk kk
k
' =∂
∂(4.11a)
y notando que
( )∂∂
Eo
d ok
k k= − − (4.11b)
Se puede reescribir la fórmula (4.10) como sigue
( ) ( )δok k k k kd o f net= − ⋅ ' , para k = 1 2, , ... , K (4.12)
La ecuación (4.12) muestra que el término error de señal δok describe el error
local ( )d ok k− a la salida de la neurona k-ésima escalado por el factor multiplicativo
( )f netk k' , que es la pendiente de la función de activación computada en el siguiente
valor de activación
( )net f ok k= −1
La fórmula final para el ajuste de pesos de la red de dos capas puede obtenerse
desde (4.8) como
( ) ( )∆w d o f net ykj k k k k j= ⋅ − ⋅ ⋅η ' (4.13a)
Los valores de los pesos actualizados resultan
w w wkj kj kj' = + ∆ para k J= =1 2 1 2, , ... , , , ... , K y j (4.13b)
La fórmula (4.13) se refiere a cualquier forma de función de activación no
lineal y diferenciable ( )f net de la neurona. Vamos a examinar la regla delta de
entrenamiento para la función de activación continua unipolar definida en (3.3 ). Para
λ = 1, ( )f net' puede ser obtenida como
( ) ( )( )[ ]
f netnet
net'
exp
exp=
−
+ −12
(4.14a)
Esta ecuación puede ser reescrita como
( ) ( )( )( )f net
netnet
net'
expexp
exp=
+ −⋅+ − −+ −
11
1 11
(4.14b)
o, si usamos (3.3) otra vez, ésta puede ser rearreglada de manera que envuelva los
valores de salida solamente
( ) ( )f net o o' = −1 (4.14c)
Vamos también a observar que el valor delta de (4.12) para esta elección de la
función de activación resulta
( ) ( )δok k k k kd o o o= − ⋅ ⋅ −1 (4.15)
Haciendo sumario de la discusión anterior, los pesos individuales actualizados
bajo la regla delta de entrenamiento pueden ser expresados para
k = =1 2 1 2, , ... , , , ... , K y j J , como sigue
( ) ( )w w d o o o ykj kj k k k k j' = + ⋅ − ⋅ ⋅ − ⋅η 1 (4.16)
para
( )onetk
k
=+ −
11 exp
Los pesos actualizados bajo la regla delta de entrenamiento para la red de dos
capas mostrada en la figuara 4.1 pueden ser expresados usando notación vectorial
W W yot'= + ⋅ ⋅η δ (4.17)
donde el vector error de señal δo es definido como un vector columna formado por los
términos individuales de error de señal:
δ
δδ
δ
o
o
o
oK
=
∆
1
2
!
Las entradas error de señal δok son dadas por (4.12) en el caso general, o por
(4.15) en el caso de función de activación continua unipolar. Hay que reseñar que las
entradas δok son señales de error local dependientes sólo de ok k y d de la neurona k-
ésima. El vector de patrones en el espacio de entrada es de dimensión J. Los valores de
entrada y j , para j =1 2, , ... , J , no están limitados.
El algoritmo de entrenamiento se resume a continuación.
Sumario del Algoritmo de entrenamiento de propagación hacia atrás del error
Dados P pares de entrenamiento
y d y d y dp p1 1 2 2, , , , ... , , ,
donde y J Ki i es d es e i P( ), ( ), , , ... , .× × =1 1 1 2 El entero q denota el paso
de entrenamiento y p denota el contador que lleva la cuenta del ciclo de entrenamiento.
PASO 1: Se elige una constante de aprendizaje η > 0 y se pone una cota a los
errores de las señales deseadas en las salidas (Emax).
PASO 2: Los pesos W son inicializados con pequeños valores aleatorios; W es
de dimensión ( )K J× :
q ← ← ←1 1 0, , p E
PASO 3: El paso de entrenamiento empieza aquí. La entrada es presentada y la
salida computada:
y y dp p← ←, d
o f wk jt← =( ), , , ... , para k K1 2
donde w k , es la k-ésima fila de W y ( )f net es la fórmula definida en (3.3).
PASO 4: Los pesos son actualizados:
( ) ( )w w d o o o yk k k k k k← + ⋅ − ⋅ ⋅ − ⋅ =η 1 1 2, , , ... , para k K
donde w k es la k-ésima fila de W.
PASO 5: El ciclo acumulativo del error es computado añadiendo el error
presente a E:
( )E d o Ek k← − + =12
1 22 , , , ... , para k K
PASO 6: Si p P entonces p q aso < ← + ← + p q e ir al P 1 1 3, , ; si no quedan
patrones por computar, ir al paso 7.
PASO 7: El ciclo de entrenamiento se ha completado. Si el error ha alcanzado
cotas inferiores al Error máximo, la sesión de entrenamiento se da por finalizada. El
valor de los pesos final será el que se utilizará definitivamente en el sistema.
Si el error supera al Error máximo permitido, entonces E ← ←0 1, p , y se
inicia un nuevo ciclo de entrenamiento desde el paso 3.
4.2. Regla delta generalizada de aprendizaje
Vamos ahora a enfocar la generalización de la regla delta de entrenamiento
para redes neuronales feedforward multicapa. La arquitectura de la red mostrada en la
figura 4.2 presenta, estrictamente hablando, dos capas de neuronas procesadoras. Sin
embargo, contando la capa con los nodos de entrada, la red puede ser catalogada como
una red de tres capas. No hay un acuerdo en la literatura técnica sobre si hay que
llamarla una red de dos o de tres capas. En el desarrollo del proyecto se adopta el
criterio de contar también la capa con los nodos de entrada.
figura 4.2: Red neuronal feedforward multicapa con tres capas de perceptrones
continuos.
Así pues, la red de la figura 4.2 es una red de tres capas. Notemos que una red
con N capas tiene N − 2 capas de neuronas cuyas salidas no son accesibles.
Las capas con neuronas cuyas salidas no son directamente accesibles se
denominan capas internas o capas escondidas. Así pues, todas las capas excepto la de
salida y la de entrada son capas escondidas. Ya que la salida de las neuronas de la capa j
no es accesible desde la entrada y la salida, la red de la figura 4.2 puede definirse como
una red de una capa escondida. En consideraciones subsiguientes, se deriva una
expresión general del incremento de peso ∆v ji para cada capa de neuronas que no es
una capa de salida.
La fórmula del descenso negativo de gradiente (4.3a) para la capa escondida
ahora es
∆v Evji
ji
= − ⋅ = =η ∂∂
, , , . . . , , , . . . , para j J e i I1 2 1 2 (4.18a)
y la fórmula (4.5) resulta
∂∂
∂∂
∂∂
Ev
Enet
netvji j
j
ji
= ⋅( )
( ) (4.18b)
Notemos que las entradas a la capa son xi , , , ... , para i I= 1 2 . Basado en la
relación (4.6), el segundo término del producto (4.18b) es igual a xi , y podríamos
expresar el ajuste de pesos similarmente a (4.8) como
∆v xji yj i= ⋅ ⋅η δ (4.18c)
donde δyj es el término error de señal de la capa escondida con salida y. Este
término error de señal es producido por la neurona j-ésima de la capa escondida, donde
j = 1 2, , ... , J . El término error de señal es igual a
δ δδyj
j
Enet
=− =∆
( ), , , ... , para j J1 2
(4.19)
En contraste con la excitación de las neuronas de la capa de salida net k , la cual
afecta sólo a la k-ésima neurona de salida, el término net j contribuye ahora a cada
componente de error en la suma del error conteniendo K términos especificados en la
expresión (4.2). El término error de señal δyj en el nodo j puede ser computado como
sigue:
δ δδ
∂∂yj
j
j
j
Ey
ynet
= − ⋅( )
(4.20a)
donde
[ ] ∂∂
∂∂
Ey y
d f net yj j
k kk
K
= −
=∑1
2 1
2
( )(4.20b)
y, obviamente, el segundo término de (4.20a) es igual a
∂∂
ynet
f netj
jj j( )' ( )=
(4.20c)
Los cálculos de rutina de (4.20b) resultan en
[ ] ∂∂
∂∂
Ey
d oy
f net yj
k kj
kk
K
= − −=∑ ( ) ( )
1
(4.21a)
El cálculo de la derivada contenido en la expresión (4.21a) produce
∂∂
∂∂
Ey
d o f netnetyj
k k kk
jk
K
= − − ⋅ ⋅=∑ ( ) ' ( )
( )
1
(4.21b)
Podemos simplificar la expresión superior en la forma compacta siguiente
usando la expresión (4.12) para δok y (4.3b) para net k .
∂∂
δEy
wj
ok kjk
K
= − ⋅=∑
1
(4.21c)
Combinando (4.20c) y (4.21c) resulta que podemos reescribir la δyj expresada
en (4.20a) de la forma
δ δyj j j ok kjk
K
f net w= ⋅ ⋅ ==∑' ( ) , , , ... , para j J1 2
1
(4.22)
El ajuste de pesos (4.18c) en la capa escondida ahora resulta
∆v f net x w para jji j j i ok kjk
K
= ⋅ ⋅ ⋅ ⋅ = ==∑η δ' ( ) , , , ... , , , ... ,1 2 1 2
1
J e i I(4.23a)
donde los términos f netj j' ( ) tienen que ser computados en (4.14c) como en el
caso del entrenamiento de la regla delta simple. La fórmula (4.23a) expresa la llamada
regla delta generalizada de aprendizaje. El ajuste de los pesos que conducen a la neurona
j en la capa escondida es proporcional a la suma ponderada de todos los valores δ en la
siguiente capa adyacente de nodos conectando la neurona j con la salida. Los pesos que
salen del nodo j son ellos mismos los factores de ponderación. Los pesos que afectan al
término δyj de la neurona escondida j-ésima han sido remarcados en la capa de salida de
la figura 4.2. Todos los errores de la capa de salida δok kjw⋅ =, , , ... , para k K1 2
contribuyen al ajuste de los pesos remarcados vij , para i = 1 2, , ... , I de la capa
escondida. Los pesos modificados de la capa escondida pueden ser expresados ahora
como
v v f net x wji ji j j i ok kjk
K
' ' ( ) , , , ... , , , ... ,= + ⋅ ⋅ ⋅ = ==∑η δ para j J e i I1 2 1 2
1
(4.23b)
El ajuste de pesos de la capa escondida basado en la regla delta generalizada de
entrenamiento para la red de la figura 4.2 puede ser expresado en notación vectorial
como
V V xyt' = + ⋅ ⋅η δ (4.24)
donde
x
xx
xI
=
1
2
!, V
v v vv v v
v v v
I
I
J J JI
=
11 12 1
21 22 2
1 2
"
"
! ! " !
"
y δy es el vector columna con entradas δyj dadas por (4.22).
Definiendo ahora la columna j-ésima de la matriz W como w j , el vector δy
puede ser expresado de forma compacta como sigue
δ δy jt
o yw f= ⋅ ⋅ ' (4.25)
donde fy ' es el vector columna con entradas fyj ' expresado para cada capa
escondida de neuronas 1, 2, ..., J, para la función de activación unipolar, como
f y yyj j j' ( )= ⋅ −1 (4.26a)
El vector δo usado en (4.25) es definido como en (4.17).
La comparación de la regla delta de entrenamiento (4.17) para el ajuste de los
pesos de la capa de salida con la regla delta generalizada de entrenamiento (4.24) para el
ajuste de los pesos de la capa escondida indica que ambas fórmulas son claramente
uniformes. La diferencia más significativa está en el etiquetaje referente a la
localización de los pesos y las señales de entrada, y en la manera en la que el vector
error de señal δ es computado. El vector δo contiene entradas escalares (4.15). Cada
componente del vector δo es simplemente la diferencia entre los valores deseados y los
valores actuales a la salida por la derivada de la función de activación. Sin embargo, el
vector δy contiene entradas que son productos escalares w fjt
o yj⋅ ⋅δ ' expresando la
suma ponderada de las contribuciones de las señales de error δo producidas por la
siguiente capa. La regla delta generalizada de aprendizaje propaga el error hacia atrás
por una capa, permitiendo que el mismo proceso sea repetido en cada capa predecesora
a la capa discutida j. En la siguiente sección formalizaremos el método de entrenamiento
para redes neuronales multicapa.
4.3. Fase feedforward y Entrenamiento de propagación hacia atrás del
error
Como se vio en la sección anterior, la red mostrada en la figura 4.2 necesita ser
entrenada en un modo supervisado. Los vectores patrón de entrenamiento x deben
presentarse emparejados con los vectores respuesta deseada d provistos por el profesor.
Vamos a mirar hacia la operación feedforward de una red. Como resultado de esta
operación la red computa el vector de salida o.
4.3.1. Fase fedforward
En general, la red multicapa está mapeando el vector de entrada x en el vector
de salida o como sigue
[ ]o N x= (4.27)
donde N denota un operador compuesto no lineal de matriz. Para la red de tres
capas mostrada, el mapeado x o→ como en (4.27) puede ser representado como un
mapeado de un mapeado, o bien
[ ][ ]o W V x= ⋅Γ Γ (4.28a)
donde el mapeado interno es
[ ]Γ V x y⋅ = (4.28b)
y realiza el mapeado de la capa escondida x y→ . Las flechas hacia la derecha
denotan mapeado de un espacio a otro. Cada uno de los mapeados es realizado por una
única capa de la red multicapa. El operador Γ es un operador no lineal diagonal con
elementos diagonales siendo idénticas funciones de activación definidas como en (4.1a).
Los elementos diagonales de Γ operan con los valores net producidos en las entradas de
cada neurona. De (4.28) sigue que los argumentos f(.) aquí son elementos de los
vectores net j k y net para las capas escondida y de salida respectivamente.
Como puede verse en (4.28b), la asunción de idénticas y fijas funciones de
activación f(net) conduce a la conclusión que los únicos parámetros para mapear x o→
tales que o proporcione d son pesos. Especificamente, tenemos dos matrices V y W que
deben ser ajustadas de manera que el valor proporcional al error d o−2
sea
minimizado. Así pues, podemos mirar las redes neuronales multicapa como sistemas
versátiles de mapeado no lineal con pesos sirviendo como parámetros.
4.3.2. Entrenamiento de propagación hacia atrás del error
La figura 4.3a ilustra el flujograma del algoritmo de entrenamiento de
propagación hacia atrás del error para una red básica de tres capas como la de la figura
4.2.
El entrenamiento empieza con la fase feedforward (Paso 2). Después de que un
solo vector patrón x es sometido a la entrada, las respuestas de capa y y o son
computadas en esta fase. Entonces, continua la fase de computación del error de señal
(Paso 4). El vector error de señal debe ser determinado primero en la capa de salida, y
entonces es propagado hacia los nodos de entrada de la red. Los K J× pesos de la
matriz W son subsiguientemente ajustados en el Paso 5. Finalmente, los pesos J I× de
la matriz V son ajustados en el Paso 6.
El error acumulativo de ciclo del mapeado de la entrada a la salida es
computado en el Paso 3 como una suma sobre todos los errores continuos de salida en
toda la serie de entrenamiento. El valor final del error para todo el ciclo de
entrenamiento es calculado después de cada paso completado a través de la serie de
entrenamiento x p1 2, , ... , x x . El procedimiento de aprendizaje se detiene cuando el
valor del error final está por debajo del máximo error tolerado E max , tal y como se
muestra en el Paso 8.
Figura 4.3a: Flujograma del algoritmo de entrenamiento de propagación hacia
atrás del error.
La figura 4.3b representa el diagrama de bloques de la operación de
entrenamiento de propagación hacia atrás del error, y explica tanto el flujo de la señal
como el flujo del error a través de la red.
Figura 4.3b: Diagrama de bloques ilustrativo del flujo de señal hacia delante y
hacia atrás del algoritmo de entrenamiento de propagación hacia atrás del error.
La porción sombreada del diagrama es la fase feedforward. La porción blanca
del diagrama se refiere al modo de entrenamiento de la red. La propagación hacia atrás
del error ( d o− ) desde cada salida, para k = 1 2, , ... , K , usando la técnica del
descenso del gradiente negativo está dividida en pasos funcionales tales como el cálculo
del vector error de señal δo y el cálculo del ajuste de matriz ∆W de la capa de salida.
El diagrama también ilustra el cálculo del vector error de señal interna δy y del ajuste
resultante de los pesos ∆V de la capa de entrada.
El algoritmo del entrenamiento de propagación hacia atrás del error se resume a
continuación.
Sumario del Algoritmo de entrenamiento de propagación hacia atrás del error
Dados P pares de entrenamiento
x d x d x dp p1 1 2 2, , , , ... , , ,
donde x I Ki i es d es e i P( ), ( ), , , ... , .× × =1 1 1 2 Se selecciona el tamaño J
de la capa escondida teniendo por salidas y j ; y es de dimensión ( )J × 1 y o es ( )K × 1 .
PASO 1
Se elige una constante de aprendizaje η > 0 y se pone una cota a los errores de
las señales deseadas en las salidas (Emax).
Los pesos W y V son inicializados con pequeños valores aleatorios; W es de
dimensión ( )K J× , mientras que V es de dimensión ( )J I× .
q ← ← ←1 1 0, , p E
PASO 2
El ciclo de entrenamiento empieza aquí. Al producirse un muestreo, se
inicializa el vector de entrada y, a partir del mismo, las salidas de las diferentes capas de
las redes son computadas.
x x dp p← ←, d
y f vj jt← =( ), , , ... , para j J1 2
donde v j , un vector columna, es la j-ésima fila de V, y
o f wk kt← =( ), , , ... , para k K1 2
donde w k , un vector columna, es la k-ésima fila de W.
PASO 3
Los valores de los errores son computados:
( )E d o Ek k← − + =12
1 22 , , , ... , para k K
PASO 4
Se computan los vectores error de señal δo (capa de salida) y δy (capa
intermedia).
El vector δo es ( )K × 1 , δy es ( )J × 1 .
Los términos error de señal de la capa de salida en este paso son
( )( )δok k k k kd o o o= − − =1 1 2, , , ... , para k K
Los términos error de señal de la capa escondida en este paso son
( )δ δyj j j ok kjk
K
y y w= − ==∑1 1 2
1
, , , ... , para j J
PASO 5
Se ajustan los pesos de la capa de salida.
w w ykj kj ok j← + ==
ηδ , , , ... ,, , ... ,
para k K y j J
1 21 2
PASO 6
Se ajustan los pesos de la capa escondida.
v v xji ji yj i← + ==
ηδ , , , ... ,, , ... ,
para j J e i I
1 21 2
PASO 7
Si p P entonces p q aso dan patrones por pasar ir al Paso < ← + ← + p q e ir al P si no que1 1 2 8, , ;
PASO 8
El ciclo de entrenamiento se ha completado. Si el error ha alcanzado cotas
inferiores al Error máximo, la sesión de entrenamiento se da por finalizada. El valor de
los pesos final será el que se utilizará definitivamente en el sistema.
Si el error supera al Error máximo permitido, entonces E ← ←0 1, p , y se
inicia un nuevo ciclo de entrenamiento desde el paso 2.
4.3.3. Errores de entrenamiento
Todos los algoritmos de entrenamiento supervisado conllevan la reducción de un
valor de error. Para el propósito del ajuste de pesos en un paso único de entrenamiento,
el error que tiene que ser reducido es usualmente computado sólo para el patrón en curso
aplicado a la entrada de la red. Para el propósito de valorar la calidad y éxito del
entrenamiento, sin embargo, el error global debe ser computado para toda la serie de
patrones de entrenamiento. A continuación se marcan las pautas sobre las principales
definiciones de errores usadas para la evaluación de entrenamiento de redes neuronales.
El error acumulativo es computado sobre el ciclo de entrenamiento de
propagación hacia atrás del error (paso 3 del algoritmo), y es expresado como un error
cuadrático
( )E d opk pkk
K
p
P
= −==∑∑1
22
11
(4.29)
Este error es una suma de P errores computados por patrones únicos usando la
fórmula (4.2). Puede verse que el error de la ecuación (4.29) perfila la exactitud del
mapeado de red neuronal después de un número de ciclos de entrenamiento han sido
implementados. Tal definición del error, sin embargo, no es muy útil para comparación
de redes con diferentes números de patrones de entrenamiento y teniendo un número
diferente de neuronas de salida. Las redes con el mismo número de salidas K que son
entrenadas usando gran cantidad de patrones en la serie de entrenamiento usualmente
producirán grandes errores acumulativos (4.29) debidos al gran número de términos en
la suma. Por razones similares, redes con un número K elevado entrenadas usando la
misma serie de entrenamiento producirán también grandes errores acumulativos. Así
pues, una más adecuada medida de error puede ser introducida como en (4.30):
( )EPK
d orms pk pkk
K
p
P
= ⋅ −==∑∑1 2
11 (4.30)
El valor eficaz E rms tiene el sentido de un error cuadrático normalizado, y es
más descriptivo que el error visto en (4.29).
En algunas aplicaciones, las respuestas continuas de las redes son de relevancia y
así pues cualquiera de las medidas de error discutidas E y E rms aportan información útil.
El grado de asociación o la exactitud del mapeado puede ser medido por estas medidas
continuas del error.
4.4. Factores de aprendizaje
El algoritmo de aprendizaje de propagación hacia atrás en el que los pesos
sinápticos son modificados sistemáticamente de manera que la respuesta de la red se
aproxime cada vez más a la deseada puede ser interpretado como un problema de
optimización. El criterio que sigue el algoritmo genérico de optimización de la función
error es simplemente el descenso negativo de gradiente con un tamaño de paso fijo. La
función error de salida (4.2), que sirve como una función objetivo, es definida sobre
todo el espacio de pesos, que tiene J(I+K) dimensiones. El algoritmo de aprendizaje
modifica las matrices de pesos de manera que el valor del error decrece.
La esencia del algoritmo de propagación hacia atrás del error es la evaluación de
la contribución de cada peso particular al error de salida. Esto es a menudo tratado
como un problema de asignación de crédito, ya que la función objetivo de una red
neuronal contiene funciones continuas derivables de los pesos, la evaluación de la
asignación de crédito puede ser cumplida numéricamente de forma sencilla.
Podría parecer que el algoritmo de propagación hacia atrás es la solución
definitiva en el aprendizaje supervisado de redes neuronales multicapa. En la práctica,
sin embargo, la implementación del algoritmo puede encontrar diferentes dificultades.
Las dificultades son típicas de aquellas que se suscitan en otras aproximaciones
multidimensionales de optimización. Uno de los problemas es que el procedimiento de
minimización de error puede ser que produzca sólo un mínimo local de la función error.
La figura 4.4 muestra una típica sección de cruce de un espacio de error en una sola
dimensión de peso. Puede verse que el error es una función no negativa de la variable
peso. El mapeado ideal reduciría el E rms a cero.
En la práctica, sin embargo, el aprendizaje podría considerarse exitoso para E rms
por debajo de un valor de E rms mínimo aceptable. La función error mostrada en la
figura 4.4 posee un mínimo global por debajo del valor mínimo de E rms , pero también
tiene dos mínimos locales en w I I1 2 y w y un punto estacionario en w s . El
procedimiento de aprendizaje parará prematuramente si se parte del punto 2 o del 3; así
pues la red entrenada será incapaz de producir la realización deseada en términos de su
error final aceptable. Para asegurar la convergencia a un mínimo satisfactorio, el punto
inicial debería ser cambiado a 1. Es más, hay una cuestión sobre cuanto tiempo llevaría
el aprendizaje de una determinada red. Una apropiada elección de los parámetros de
aprendizaje debería garantizar que una solución de buena calidad sea encontrada en un
periodo razonable de tiempo de computación.
Figura 4.4: Minimización del error eficaz como función de un solo peso.
Aunque el esquema del descenso negativo de gradiente y todas las otras técnicas
de optimización pueden llegar a atascarse en un mínimo local de la función de error,
esto no ha ocurrido en la mayoría de casos estudiados. Si llega a producirse, como estos
mínimos no son demasiado profundos, la inserción de alguna forma de aleatoriedad al
entrenamiento podría ser suficiente para salir del mínimo.
Sin embargo, una explicación más convincente de las razones por las que los
mínimos locales no son un problema grave en este procedimiento de entrenamiento
tiene su fondo en la naturaleza estocástica del algoritmo. Las superficies de error
cuadrático producidas son aleatorias. A lo largo de todo el espacio de error, el mejor
debería ser el resultado del entrenamiento. De hecho, la técnica de propagación hacia
atrás del error se considera equivalente a una forma de aproximación estocástica
explorada a principios de los 60 (Tsypkin 1973). El aspecto más nuevo del algoritmo es
que es computativamente eficiente para el estudio empírico de las técnicas estocásticas
de aproximación (White 1989).
Uno de los factores que usualmente mejoran la convergencia del entrenamiento
es la naturaleza estadística de las entradas y las salidas. También, incluso cuando las
entradas son puramente deterministas, la superposición de ruido con valor medio cero
puede incrementar la eficiencia del proceso de entrenamiento. Sin embargo, en ausencia
de teorías sólidas, el modelador de redes neuronales debe fiarse a menudo de la
experimentación y en comprender los principios básicos de la red para conseguir
resultados satisfactorios.
A continuación se tratará sobre la solución de convergencia del algoritmo de
propagación hacia atrás. También se enfoca hacia algunos aspectos y propiedades del
algoritmo. Las más importantes de estas son los pesos iniciales, ajuste acumulativo de
pesos, la forma de la función de activación de la neurona, y la selección de la constante
de aprendizaje y del término momento. También discutiremos aspectos seleccionados
de la arquitectura de redes que son relevantes para un entrenamiento exitoso.
4.4.1. Pesos iniciales
Los pesos de la red a ser entrenada deben incializarse con pequeños valores
aleatorios. La inicialización afecta fuertemente a la solución final. Si todos los pesos
empezasen con valores de peso iguales, y la solución requiriese el desarrollo de pesos
distintos, la red podría no entrenarse correctamente. A menos que la red sea alterada por
factores aleatorios o que los patrones de entrada sean de naturaleza estadística, la
representación interna puede resultar continuamente en pesos simétricos.
También, la red puede fallar para aprender la serie de ejemplos de entrenamiento
con el error estabilizándose o incluso incrementándose al continuar el aprendizaje. De
hecho, muchos estudios empíricos del algoritmo apuntan a que si se continúa
entrenando después una cierta meseta con bajo error resulta en el indeseable arrastre de
los pesos. Esto provoca el aumento del error y la calidad de mapeado implementado por
la red decrece. Para contrarrestar el problema del arrastre, el aprendizaje de la red debe
reinicializarse con otros valores aleatorios de los pesos. La elección de los pesos
iniciales, sin embargo, es sólo uno de los múltiples factores que afectan al
entrenamiento de la red hacia un aceptable error mínimo.
4.4.2. Ajuste de pesos acumulativo versus actualización por incrementos
Como se expuso anteriormente, el aprendizaje de propagación hacia atrás basado
en la reducción de error de un único patrón (4.2) requiere un ajuste pequeño de pesos
que se produce cada vez que se presenta un patrón de entrenamiento. Este esquema es el
llamado actualización por incrementos. Como mostraron McClelland y Rumelhart
(1986), el aprendizaje de propagación hacia atrás también implementa una
minimización tipo descenso de gradiente de la función de error sobre toda la red como
se definió en (4.29) computada sobre el ciclo completo de P presentaciones, proveída la
constante de aprendizaje η suficientemente pequeña.
La ventaja de la minimización del error de un único patrón como se ilustró en el
diagrama de flujo de la figura 4.3 y se resumió en el algoritmo EBPT de la sección 4.3
es que el algoritmo implementa un descenso de gradiente verdadero hacia abajo de la
colina de la superficie de error. Es más, durante la simulación de computador, los
ajustes de peso determinados por el algoritmo no necesitan ser guardados y
gradualmente compuestos sobre el ciclo de aprendizaje consistente en P pasos de señal
de error conjunto y computación de ajuste de pesos. La red entrenada de esta manera,
sin embargo, puede tender hacia los más recientes patrones en el ciclo. Para
contrarrestar este problema específico, una pequeña constante de aprendizaje η debe
usarse o cambios de peso acumulativos impuestos como sigue
∆ ∆w w pp
P
==
∑1
para las capas de salida y escondida(s). El ajuste de pesos en este esquema es
implementado a la conclusión del ciclo completo de aprendizaje. Sin embargo, esto
puede tener un efecto promedio en el entrenamiento. Proporcionando una constante de
aprendizaje suficientemente pequeña, el procedimiento de ajuste acumulativo de pesos
puede todavía implementar el algoritmo cerca de la minimización de descenso de
gradiente.
Aunque tanto el ajuste acumulativo de pesos después de cada ciclo completado
de entrenamiento como el ajuste de pesos incremental después de cada presentación de
un patrón simple puede traer soluciones satisfactorias, debe prestarse atención al hecho
de que el entrenamiento funciona mejor bajo condiciones aleatorias. Así pues, parece
aconsejable usar la actualización de pesos incremental después de cada presentación de
patrones, pero escogiendo patrones en una secuencia aleatoria de la serie de
entrenamiento. Esto introduce la necesidad de mucho ruido en el entrenamiento y alivia
los problemas de promedio y señales sesgadas que tendirían a favorecer a los más
recientes patrones de entrenamiento.
4.4.3. Pendiente de la función de activación
La función continua de activación de neurona ( )f net,λ está caracterizada por su
factor de pendiente λ . También, la derivada ( )f net' de la función de activación sirve
como factor multiplicativo en la construcción de componentes de los vectores error de
señal δ δo y y . Así pues, tanto la elección como la pendiente de la función de activación
afectarán fuertemente a la velocidad de aprendizaje de la red.
La derivada de la función de activación (3.3) puede ser fácilmente computada
como sigue:
( )( )
f nete
e
net
net' =
⋅
+
− ⋅
− ⋅
λ λ
λ12
(4.31)
y alcanza su valor máximo de 14
⋅ λ en net = 0. La figura 4.5 muestra la función
pendiente de la función de activación e ilustra como la pendiente λ afecta al proceso de
aprendizaje.
La otra prestación que se deriva de la figura 4.5 es que para una constante fija de
aprendizaje todos los ajustes de pesos están en proporción con el coeficiente de
pendiente λ . Esta observación particular conduce a la conclusión de que el uso de
funciones de activación con grandes λ puede proporcionar resultados similares a los
que se obtienen usando grandes constantes de aprendizaje η . Así pues parece
aconsejable mantener λ en un valor estándar de 1, y controlar la velocidad de
aprendizaje usando únicamente la constante de aprendizaje η , mejor que controlar η y
λ simultáneamente. Sin embargo, esto depende del sistema en el que se sitúen las
redes.
Figura 4.5: Pendiente de la función de activación para diferentes valores de λ .
4.4.4. Constante de aprendizaje
La efectividad y convergencia del algoritmo de aprendizaje de propagación hacia
atrás del error depende significativamente del valor de la constante de aprendizaje η .
En general, sin embargo, el valor óptimo de η depende del problema a resolver, y no
hay un único valor de la constante de aprendizaje adecuado para diferentes casos de
entrenamiento. Este problema parece ser común para todos los esquemas de
optimización basados en el gradiente. Mientras el descenso de gradiente puede ser un
método eficiente para obtener los valores de los pesos que minimizan un error, las
superficies de error poseen frecuentemente propiedades que hacen el procedimiento
lento en convergencia.
Cuando un mínimo amplio produce valores pequeños de gradiente, entonces un
valor grande de η resultará en una más rápida convergencia. Sin embargo, para
problemas con mínimos profundos y estrechos, un pequeño valor de η debe ser
escogido para evitar el rebasamiento en la solución. Esto conduce a la conclusión que η
debe ser escogida experimentalmente para cada problema. También hay que recordar
que sólo pequeñas constantes de aprendizaje garantizan un verdadero descenso de
gradiente. El precio de esta garantía es un número total de pasos de aprendizaje mayor
necesario para alcanzar la solución satisfactoria. También es deseable monitorizar el
progreso de aprendizaje de manera que η puede ser aumentada en apropiados
escenarios de entrenamiento para acelerar el proceso minimizando la búsqueda.
Aunque la elección de la constante de aprendizaje depende fuertemente de la
clase del problema de aprendizaje y de la arquitectura de la red, valores con rango desde
10 3− a 10 han sido recogidos por la literatura técnica como exitosos para muchos
experimentos de computación de propagación hacia atrás. Para grandes constantes de
aprendizaje, la velocidad de aprendizaje puede ser incrementada drásticamente; sin
embargo, el aprendizaje podría no ser exacto, con tendencias al rebasamiento, o podría
no estabilizarse nunca en un mínimo.
Incluso a pesar de que el descenso de gradiente simple pueda ser eficiente , hay
situaciones en que moviendo los pesos en un único paso de aprendizaje a lo largo del
vector de gradiente negativo con una proporción fija se producirá una menor reducción
del error. Para superficies de error tipo llanura, por ejemplo, podrían requerirse
demasiados pasos para compensar el pequeño valor de gradiente. Es más, los contornos
del error podrían no tener una forma circular y el vector gradiente podría no apuntar
hacia un mínimo. Algunas heurísticas para mejorar la proporción de convergencia son
propuestas a continuación basadas en estas observaciones.
4.4.5. Método del momento
El objetivo del método es acelerar la convergencia del algoritmo de aprendizaje
de propagación hacia atrás del error. El método conlleva suplir los ajustes de los pesos
actuales (4.3) y (4.18a) por una fracción del más reciente ajuste de pesos. Usualmente
se hace siguiendo la fórmula:
∆ ∆w t E t w t( ) ( ) ( )= − ⋅ ∇ + ⋅ −η α 1 (4.32a)
donde los argumentos t y t − 1 indican los pasos de entrenamiento actual y más
reciente, respectivamente, y α es una constante (del momento) positiva seleccionada por
el usuario. El segundo término indica un escalado del ajuste de pesos anterior y es
llamado término momento. Para el total de N pasos usando el método del momento, el
cambio del peso actual puede ser expresado como
∆w t E t nn
n
N
( ) ( )= − ⋅ ⋅ ∇ −=
∑η α0
(4.32b)
Típicamente α es escogida entre 0.1 y 0.8. La figura 4.6 ilustra la heurística del
método del momento y provee la justificación para su uso.
Figura 4.6: Efecto producido por la adición del término momento en el
entrenamiento de propagación hacia atrás del error para un caso de dos dimensiones.
Vamos a iniciar el procedimiento descenso de gradiente en el punto A’. Las
derivadas consecutivas δE/δw1 y δE/δw2 en los puntos de entrenamiento A’, A’’,..., son
del mismo signo. Obviamente, combinando los componentes de gradiente de muchos
escalones adyacentes resultaría en una convergencia más veloz. Si el error de superficie
tiene una variación suave a lo largo de un cierto eje, la proporción de aprendizaje a lo
largo de este componente particular debería ser incrementada. Mediante la adición del
término momento, el ajuste de peso en A’’ es aumentado por la fracción del ajuste de
pesos en A’.
Después de empezar el procedimiento de descenso de gradiente en B’, las dos
derivadas δE/δw1 y δE/δw2, inicialmente negativas en B’, alteran sus signos en B’’. La
figura indica que el gradiente negativo no provee una dirección eficiente del ajuste de
peso porque el desplazamiento deseado para B debería ser más hacia el mínimo M, o
mover el vector peso a lo largo del valle en lugar de a través de él. Como se ve en la
figura, el desplazamiento η ⋅ ∇ +E t( )1 en B’’ movería los pesos por una magnitud
bastante larga casi a través del valle y cerca del punto inicial B’. Moviendo los pesos
por − ⋅ ∇ + + ⋅η αE t w t( ) ( )1 ∆ , sin embargo, se reduce la magnitud del ajuste de peso y
apunta al vector resultante ∆w t( )+ 1 más a lo largo del valle. Se puede incluso inferir
que si los componentes de gradiente cambian los signos en dos iteraciones consecutivas,
la proporción de aprendizaje a lo largo de este eje debería ser decrementada. Incluso
esta discusión indica que el término momento ayuda a acelerar la convergencia y a
conseguir un perfil eficiente y fidedigno.
4.4.6. Número necesario de neuronas ocultas
La determinación del número total de capas y la medida de la capa escondida
son algunas de las más importantes consideraciones cuando se resuelven problemas
actuales usando redes feedforward multicapa. Estos problemas están bajo estudio
intensivo sin respuestas concluyentes útiles para muchas tareas. El análisis exacto de la
solución es bastante dificultoso por la complejidad del mapeado de la red y debido a la
naturaleza no determinista de muchos procedimientos de entrenamiento completados
con éxito. En esta sección veremos algunas líneas guía que pueden asistir a un
modelador de red neuronal con un número de sugerencias útiles.
Se sabe que generar una sola capa oculta con un número adecuado de
elementos es equivalente, en cuanto a los problemas que resuelve, a una red con un
número arbitrario de ellas. Esta aproximación, sin embargo, sí tiene influencia en las
fases de entrenamiento. Podemos deducir, por tanto, que una red con una única capa
oculta resuelve el mismo número de problemas que una red con varias. Lo que queda es
calcular el número de neuronas a situar en esa capa.
Se ha comprobado empíricamente que un número excesivo de neuronas no
sólo tendrá una presencia superflua, sino que su influencia en el proceso adaptativo es
negativo, dificultando la generalización.
Las redes de una sola capa escondida pueden formar regiones de decisión
arbitrarias en el espacio n-dimensional de patrones de entrada. Existen determinadas
soluciones útiles como el número J de neuronas escondidas para realizar una
determinada función adecuadamente. Las soluciones también determinan el límite
inferior en cuanto al número de patrones diferentes P requeridos en la serie de
entrenamiento. Como se verá, el número de neuronas escondidas depende de la
dimensión n del vector de entrada y del número de regiones separables en el espacio
euclideano n-dimensional de entrada.
Vamos a asumir que el espacio n-dimensional de entrada es linealmente
separable en M regiones disjuntas con fronteras que forman parte de hiperplanos. Cada
una de las M regiones en el espacio de entrada puede ser etiquetada como perteneciente
a una de R clases posibles, donde RM. La figura 4.7 muestra un ejemplo de separación
para n = = =2 7 3, , M y R . Intuitivamente resulta obvio que el número de regiones
separables M indica la cota más baja en el tamaño P de la serie requerido para un
entrenamiento significativo de la red a diseñar. Así pues debemos tenemos que P≥M.
Figura 4.7 Espacio de entrada de dos dimensiones con siete regiones
separables asignadas a una de tres clases posibles.
Escogiendo P M= tendríamos la más basta separación posible del espacio de
entrada en M regiones separadas por hiperplanos particionantes. En un caso tal en que
un patrón de entrenamiento por región es obtenible, la granularidad de la clasificación
propuesta no es del todo fina.
Escogiendo PM
>> 1 será posible la discriminación de clases de patrones
usando un particionamiento de hiperplano con trozos finos.
Existe una relación entre M, J y n permitiendo el cálculo de uno de los tres
parámetros, dados los otros dos. Como mostraron Mirchandini y Cao (1989), el número
máximo de regiones linealmente separables usando J neuronas escondidas en el espacio
n-dimensional de entrada es dado por la relación
M J nJ
k
J
kk
k
n
( , ) ,=
= <
=∑ donde para J0
0 (4.33a)
El uso de la fórmula (4.33a) permite la estimación del tamaño de la capa
escondida J dadas n y M. Una simple computación muestra que la red que provee la
clasificación ilustrada en la figura 4.7 debería tener tres neuronas en la capa escondida
teniendo en cuenta que los patrones de entrada son de dimensión dos, n=2. Vamos a
considerar el caso de patrones de entrada de dimensión grande asumiendo el tamaño de
la capa oculta es pequeño. Para vectores de entrada de gran tamaño comparados con el
número de nodos escondidos, o cuando n≥J, tenemos según (4.33a)
MJ J J J
JJ=
+
+
+ +
=
0 1 22 L
(4.33b)
Siguiendo desde (4.33b) la capa escondida con tres nodos sería capaz de
proveer una clasificación por encima de ocho clases; pero ya que n≥J, la talla del vector
de entrada tiene que ser mayor que tres.
Las fórmulas (4.33) pueden ser invertidas para encontrar cuantas neuronas se
requieren en la capa oculta para conseguir la clasificación en M clases en el espacio n-
dimensional de patrones. Este número constituye la solución de la ecuación
M JJ J J J J J J J n
nn= + +
⋅ −+
⋅ − ⋅ −+
⋅ − − +≥1
12
1 23
1 1( )!
( ) ( )!
( ) ( )!
para J
L (4.34a)
Para el caso J n≥ tenemos para J desde (4.33b) simplemente
J M= log 2 (4.34b)
4.5. Control en modo de deslizmiento con redes neuronales de robots
manipuladores
Un control hecho directamente con redes neuronales podría haber sido
aplicado a la planta. Sin embargo, el uso de un control en modo de deslizamiento en una
etapa previa a la red neuronal, tiene ventajas de implementación y reduce el orden del
sistema y por lo tanto simplifica el trabajo de las redes. El término independiente K de
la superficie S será utilizado para controlar la posición del manipulador. Se debe tener
en consideración que las ecuaciones matemáticas son no lineales y los parámetros
inciertos.
4.5.1. Diseño del sistema con redes neuronales
Como ya se anticipó en el apartado 2.2.8.4., la variable de control K de la
superficie de deslizamiento puede ser proporcionada por una red neuronal, que se
denominará controladora (RNC). Para realizar el entrenamiento de la red, una señal de
error debe ser propagada hacia atrás a través de la red. Puesto que la variable a controlar
es la posición angular q y no la variable de control, se deberá añadir una red neuronal
emuladora (RNE) que simule el comportamiento de la planta, cuya salida será qe. La
propagación del error podrá entonces realizarse correctamente a través de las dos redes.
Por lo expuesto en el apartado 4.4.6., las redes controladora y emuladora
tendrán tres capas, una de entrada, una única capa oculta y una de salida. El número
definitivo de nodos de entrada y de neuronas de las redes se determinará por
simulación.
Capa de entrada:
Debido a que se debe obtener un comportamiento dinámico tanto de la red
emuladora como de la controladora y que el procesamiento será en tiempo discreto, se
usarán retardos de las señales del sistema. A la entrada de la RNC se tendrá el ángulo de
referencia deseado a la salida de la planta, (Ref), las dos últimas muestras de la salida K
( )z K y z K− −1 2 de la RNC y las dos últimas muestras del ángulo de salida q
( )z q y z q− −1 2 .
A la entrada de la RNE se tendrá la variable controladora K actual más sus dos
valores anteriores, y las dos últimas muestras del ángulo de salida q.
Así pues, en ambos casos se utilizarán redes con cinco nodos de entrada.
Capa oculta
Según lo visto en el apartado 4.4.6., la relación entre el número J de neuronas
escondidas y el número M de regiones separables del espacio de entrada es, según la
ecuación (4.34b), J M= log 2 . Puesto que el sistema tratado es de tiempo continuo, M se
escogerá según la precisión deseada a la salida. En el desarrollo del proyecto se adopta
el valor M = 16, y por tanto el número J de neuronas en la capa oculta es de cuatro para
las dos redes.
Capa de salida
La salida de la RNE es q em y de la RNC es K.
En la figura 4.8 puede observarse el esquema del control adaptativo diseñado.
Figura 4.8: Esquema de control con redes neuronales
Las redes presentan el esquema dibujado en la figura 4.9.
Figura 4.9: Esquema interno de las redes neuronales
En un paso previo al entrenamiento de la Red Controladora, se realiza un
entrenamiento de la Red Emuladora para obtener unos valores iniciales de la misma que
permitan la correcta propagación hacia atrás del error necesaria para el entrenamiento
de la Red Controladora. Una vez realizado este preentrenamiento o entrenamiento fuera
de línea se entrenará el conjunto de las dos redes.
4.5.2. Programa de preentrenamiento de la Red Neuronal Emuladora
El esquema de entrenamiento de la Red Emuladora es
Figura 4.10: Esquema general de entrenamiento de la RNE
En la figura siguiente se muestra el diagrama de bloques del entrenamiento, en sus fases
feedforward y propagación hacia atrás del error:
Figura 11: Diagrama de bloques del entrenamiento de la RNE
El algoritmo que sigue este diagrama es el detallado a continuación
Entrenamiento de la Red Neuronal Emuladora (RNE)
Paso 1
Se elige una constante de aprendizaje η > 0 y se pone una cota a los errores de
las señales deseadas en las salidas (Emax).
Los pesos we y ve de la RNE son inicializados con pequeños valores
aleatorios. we es de dimensión [1x4], mientras que ve es de dimensión [4x5].
También se inicializa el error de salida: EE = 0
Paso 2
El ciclo de entrenamiento empieza aquí. Al producirse un muestreo, se
inicializa el vector de entrada y, a partir del mismo, las salidas de las dos capas de
neuronas de la red son computadas.
El vector de entrada XE es de dimensión [5x1].
[ ] [ ] [ ] [ ] [ ]
[ ] [ ]
Nete ve xe i
qe we j ye j
e Nete i
j
4 1 4 5 5 11
11 2 3 4
1
4
× = × ⋅ × → =+
=
= ⋅
− ⋅
=∑
ye para i λ
, , ,
Paso 3
Computación de los valores de los errores.
( )EE EE q qe+ = + ⋅ −12
2
Paso 4
Computación de los vectores de error de señal δ O (capa de salida) y δ E (capa
intermedia).
Capa de salida:
( )δ O q qe= −
Capa escondida:
[ ] [ ] [ ]( ) [ ]δ λ δλE Oi ye i we i ara ie= ⋅ ⋅ ⋅ ⋅ =⋅- Nete i p
21 2 3 4, , ,
Paso 5
Se ajustan los pesos de la capa de salida.
[ ] [ ] [ ]we i we i ye i ara iO+ = + ⋅ ⋅ =η δ p 1 2 3 4, , ,
Paso 6
Se ajustan los pesos de la capa escondida.
[ ] [ ] [ ] [ ]ve ve xeEt+ × = × + ⋅ × ⋅ ×4 5 4 5 4 5 1 5η δ
Paso 7
Si no ha pasado toda la secuencia de referencia, cuando se produce un nuevo
muestreo se va al paso 2. Si ya pasó, se va al paso 8.
Paso 8
El ciclo de entrenamiento se ha completado. Si el error ha alcanzado cotas
inferiores al Error máximo, la sesión de entrenamiento se da por finalizada. El valor de
los pesos final será el que se utilizará definitivamente en el sistema.
Si el error supera al Error máximo permitido, entonces EE = 0 , y se inicia un
nuevo ciclo de entrenamiento desde el paso 2 pasando desde el inicio la secuencia de
entrenamiento, con valores iniciales de los pesos iguales a los finales del anterior ciclo
de entrenamiento.
NOTA: En los programas simuladores en ACSL finalmente no se incluye el
apartado 3 ya que visualmente puede observarse la evolución del error en el
entrenamiento.
Elección de los pesos iniciales, y λ η α,
Los pesos iniciales serán aleatorios según lo analizado en el apartado 4.4.1.
El valor de λ escogido es 1.
Para la elección de η se provaron diferentes valores llegando a la conclusión
de que un valor muy pequeño (0,001) produce un entrenamiento excesivamente lento
mientras que valores altos producen un continuo rebasamiento de manera que los
valores de los pesos nunca llegan a estabilizarse. Un valor que produjo resultados
satisfactorios fue η = 0 01, .
Por otra parte, la constante del término momento, también determinada a partir
de algunas pruebas, es 0.8.
Por último, la frecuencia de muestreo utilizada es f khzm = 1 (parte discreta del
controlador) y la señal de referencia utilizada es una onda senoidal con diferentes
amplitudes. En la figura 4.12 se muestra, a modo de ejemplo, la señal K que produce la
señal de referencia q suponiendo condiciones iniciales nulas.
K= As0+As1*sin(wo1*t)+As2*sin(wo2*t)+As3*sin(wo3*t)+As4*sin(wo4*t)
siendo
As0=0,As1=60,As2=70,As3=70,As4=-70
wo1=0.2,wo2=0.1,wo3=0.3333333,wo4=0.8
Figura 4.12a: Señal K para obtener la referencia
en el entrenamiento de la RNE.
Figura 4.12b: Señal de referencia en el entrenamiento de la RNE.
A continuación se muestra el programa ACSL que implementa elentrenamiento de la red.
Program EmuladorInitial
real VE(4,5),WE(4),AVE(4,5),AWE(4),BVE(4,5),BWE(4)
"-------Constantes de la planta"
Constant J=1.625e-3,m0=0.506,Mo=0.434,Lo=0.305 Constant Ro=0.023,Bo=16.25e-3,L=25e-3,R=5 Constant Kt=0.9,Kb=0.9,G=9.8,Vg=15
M=J/Kt+m0*Lo*Lo/(3*Kt)+Mo*Lo*Lo/Kt+2*Mo*Ro*Ro/(5*Kt) N=m0*Lo*G/(2*Kt)+Mo*Lo*G/Kt B=Bo/Kt
"-------coeficientes del sliding" Constant k2=1.72,k3=25,dk=2
"------Coeficientes de las ecuaciones de estado" a11=-R/L a12=-Kb/L dimension b1(2) b1(1)=Vg/L $ b1(2)=-Vg/L
"---Periodo de muestreo" Constant ts=1.0e-3 tsamp=ts
"---Constantes de tiempo del filtro reconstructor y de salida" Constant tau=10.0e-3,taus=1.0e-3
"---Condiciones iniciales de las variables de estado continuas" Constant iic=0,wic=0,qic=0,Kic=0
"-----Condicion inicial del comparador con histeresis" Integer p p=1 s=iic+k2*wic+k3*qic-Kic if(s.GT.dk) p=2
"-----Coeficientes de las redes neuronales" Constant landa=1,Ron=0.01,aa=0.8
"---Condiciones iniciales de las variables discretas de las redes neuronales" Dini= Kic D = Dini Dp = Dini qp = qic qm = qic
"----- Condiciones iniciales de los pesos de la red emuladora"
Constant px=0.1
VE(1,1)=UNIF(-px,px) $ VE(2,1)=UNIF(-px,px) VE(3,1)=UNIF(-px,px) $ VE(4,1)=UNIF(-px,px) VE(1,2)=UNIF(-px,px) $ VE(2,2)=UNIF(-px,px) VE(3,2)=UNIF(-px,px) $ VE(4,2)=UNIF(-px,px)
VE(1,3)=UNIF(-px,px) $ VE(2,3)=UNIF(-px,px) VE(3,3)=UNIF(-px,px) $ VE(4,3)=UNIF(-px,px) VE(1,4)=UNIF(-px,px) $ VE(2,4)=UNIF(-px,px) VE(3,4)=UNIF(-px,px) $ VE(4,4)=UNIF(-px,px) VE(1,5)=UNIF(-px,px) $ VE(2,5)=UNIF(-px,px) VE(3,5)=UNIF(-px,px) $ VE(4,5)=UNIF(-px,px) WE(1)=UNIF(-px,px) $ WE(2)=UNIF(-px,px) WE(3)=UNIF(-px,px) $ WE(4)=UNIF(-px,px)
BWE(1) = 0 $ BWE(2) = 0 $ BWE(3) = 0 $ BWE(4) = 0 BVE(1,1) = 0 $ BVE(1,2) = 0 $ BVE(1,3) = 0 $ BVE(1,4) = 0 BVE(1,5) = 0 $ BVE(2,1) = 0 $ BVE(2,2) = 0 $ BVE(2,3) = 0 BVE(2,4) = 0 $ BVE(2,5) = 0 $ BVE(3,1) = 0 $ BVE(3,2) = 0 BVE(3,3) = 0 $ BVE(3,4) = 0 $ BVE(3,5) = 0 $ BVE(4,1) = 0 BVE(4,2) = 0 $ BVE(4,3) = 0 $ BVE(4,4) = 0 $ BVE(4,5) = 0
AWE(1) = 0 $ AWE(2) = 0 $ AWE(3) = 0 $ AWE(4) = 0 AVE(1,1) = 0 $ AVE(1,2) = 0 $ AVE(1,3) = 0 $ AVE(1,4) = 0 AVE(1,5) = 0 $ AVE(2,1) = 0 $ AVE(2,2) = 0 $ AVE(2,3) = 0 AVE(2,4) = 0 $ AVE(2,5) = 0 $ AVE(3,1) = 0 $ AVE(3,2) = 0 AVE(3,3) = 0 $ AVE(3,4) = 0 $ AVE(3,5) = 0 $ AVE(4,1) = 0 AVE(4,2) = 0 $ AVE(4,3) = 0 $ AVE(4,4) = 0 $ AVE(4,5) = 0
"-----Constantes de la referencia variable" Constant As0=0,As1=60,As2=70,As3=70,As4=-70 Constant wo1=0.2,wo2=0.1,wo3=0.3333333,wo4=0.8
Ref= As0+As1*sin(wo1*t)+As2*sin(wo2*t)+As3*sin(wo3*t)+As4*sin(wo4*t)End $ "de initial"
Dynamic "-------Intervalo de comunicación" Cinterval Cint = 1.0e-3 "------- Condición para acabar" Constant Tstp = 199.99 Termt(T .GE. Tstp)
Derivative "-------Algoritmo de integración y tamaño del paso" Algorithm Ialg = 4 Nsteps Nstp = 1 Maxterval Maxt = 1.0e-3
"-------Variables auxiliares" M=J/Kt+m0*Lo*Lo/(3*Kt)+Mo*Lo*Lo/Kt+2*Mo*Ro*Ro/(5*Kt) N=m0*Lo*G/(2*Kt)+Mo*Lo*G/Kt
"-------Ecuaciones de estado" i=INTEG(a11*i+a12*w +b1(p),iic) w=INTEG((i-B*w-N*sin(qr))/M ,wic) qr=INTEG( w ,qic)
"-------Control" Ref= As0+As1*sin(wo1*t)+As2*sin(wo2*t)+As3*sin(wo3*t)+As4*sin(wo4*t)
K=REALPL(tau,Ref,Kic) s=i+k2*w+k3*qr-K q=REALPL(taus,qr)
"-------Cambios de subintervalo" SCHEDULE aOn .XN. s+dk SCHEDULE aOff .XP. s-dkEnd $ " of Derivative "
Discrete aOn p=1End $ " of Discrete aOn"Discrete aOff p=2End $ " of Discrete aOff"
Discrete NN INTERVAL tsamp=1.0e-3 Dpp=Dp Dp=D qpp=qp qp=qm qm=q SCHEDULE NNese .AT. t+0.0End $ " of Discrete NN"
Discrete NNese
nete1=VE(1,1)*D+VE(1,2)*Dp+VE(1,3)*Dpp+VE(1,4)*qp+VE(1,5)*qpp nete2=VE(2,1)*D+VE(2,2)*Dp+VE(2,3)*Dpp+VE(2,4)*qp+VE(2,5)*qpp nete3=VE(3,1)*D+VE(3,2)*Dp+VE(3,3)*Dpp+VE(3,4)*qp+VE(3,5)*qpp nete4=VE(4,1)*D+VE(4,2)*Dp+VE(4,3)*Dpp+VE(4,4)*qp+VE(4,5)*qpp
ye1=1/(1+EXP(-landa*nete1)) ye2=1/(1+EXP(-landa*nete2)) ye3=1/(1+EXP(-landa*nete3)) ye4=1/(1+EXP(-landa*nete4))
ype1=(landa*EXP(-landa*nete1))*ye1*ye1 ype2=(landa*EXP(-landa*nete2))*ye2*ye2 ype3=(landa*EXP(-landa*nete3))*ye3*ye3 ype4=(landa*EXP(-landa*nete4))*ye4*ye4
qe=WE(1)*ye1+WE(2)*ye2+WE(3)*ye3+WE(4)*ye4 e=q-qe SCHEDULE NNeuw .AT. t+0.0
end $ "de NNese"
Discrete NNeuw
BWE(1) = Ron*e*ye1 BWE(2) = Ron*e*ye2 BWE(3) = Ron*e*ye3 BWE(4) = Ron*e*ye4 BVE(1,1)= Ron*D*e*WE(1)*ype1 BVE(1,2)= Ron*Dp*e*WE(1)*ype1 BVE(1,3)= Ron*Dpp*e*WE(1)*ype1 BVE(1,4)= Ron*qp*e*WE(1)*ype1 BVE(1,5)= Ron*qpp*e*WE(1)*ype1 BVE(2,1)= Ron*D*e*WE(2)*ype2
BVE(2,2)= Ron*Dp*e*WE(2)*ype2 BVE(2,3)= Ron*Dpp*e*WE(2)*ype2 BVE(2,4)= Ron*qp*e*WE(2)*ype2 BVE(2,5)= Ron*qpp*e*WE(2)*ype2 BVE(3,1)= Ron*D*e*WE(3)*ype3 BVE(3,2)= Ron*Dp*e*WE(3)*ype3 BVE(3,3)= Ron*Dpp*e*WE(3)*ype3 BVE(3,4)= Ron*qp*e*WE(3)*ype3 BVE(3,5)= Ron*qpp*e*WE(3)*ype3 BVE(4,1)= Ron*D*e*WE(4)*ype4 BVE(4,2)= Ron*Dp*e*WE(4)*ype4 BVE(4,3)= Ron*Dpp*e*WE(4)*ype4 BVE(4,4)= Ron*qp*e*WE(4)*ype4 BVE(4,5)= Ron*qpp*e*WE(4)*ype4
WE(1) = WE(1)+BWE(1)+aa*AWE(1) WE(2) = WE(2)+BWE(2)+aa*AWE(2) WE(3) = WE(3)+BWE(3)+aa*AWE(3) WE(4) = WE(4)+BWE(4)+aa*AWE(4) VE(1,1)= VE(1,1)+BVE(1,1)+aa*AVE(1,1) VE(1,2)= VE(1,2)+BVE(1,2)+aa*AVE(1,2) VE(1,3)= VE(1,3)+BVE(1,3)+aa*AVE(1,3) VE(1,4)= VE(1,4)+BVE(1,4)+aa*AVE(1,4) VE(1,5)= VE(1,5)+BVE(1,5)+aa*AVE(1,5) VE(2,1)= VE(2,1)+BVE(2,1)+aa*AVE(2,1) VE(2,2)= VE(2,2)+BVE(2,2)+aa*AVE(2,2) VE(2,3)= VE(2,3)+BVE(2,3)+aa*AVE(2,3) VE(2,4)= VE(2,4)+BVE(2,4)+aa*AVE(2,4) VE(2,5)= VE(2,5)+BVE(2,5)+aa*AVE(2,5) VE(3,1)= VE(3,1)+BVE(3,1)+aa*AVE(3,1) VE(3,2)= VE(3,2)+BVE(3,2)+aa*AVE(3,2) VE(3,3)= VE(3,3)+BVE(3,3)+aa*AVE(3,3) VE(3,4)= VE(3,4)+BVE(3,4)+aa*AVE(3,4) VE(3,5)= VE(3,5)+BVE(3,5)+aa*AVE(3,5) VE(4,1)= VE(4,1)+BVE(4,1)+aa*AVE(4,1) VE(4,2)= VE(4,2)+BVE(4,2)+aa*AVE(4,2) VE(4,3)= VE(4,3)+BVE(4,3)+aa*AVE(4,3) VE(4,4)= VE(4,4)+BVE(4,4)+aa*AVE(4,4) VE(4,5)= VE(4,5)+BVE(4,5)+aa*AVE(4,5)
AWE(1) = BWE(1) $ AWE(2) = BWE(2) $ AWE(3) = BWE(3) AWE(4) = BWE(4) $ AVE(1,1) = BVE(1,1) $ AVE(1,2) = BVE(1,2) AVE(1,3) = BVE(1,3) $ AVE(1,4) = BVE(1,4) $ AVE(1,5) = BVE(1,5) AVE(2,1) = BVE(2,1) $ AVE(2,2) = BVE(2,2) $ AVE(2,3) = BVE(2,3) AVE(2,4) = BVE(2,4) $ AVE(2,5) = BVE(2,5) $ AVE(3,1) = BVE(3,1) AVE(3,2) = BVE(3,2) $ AVE(3,3) = BVE(3,3) $ AVE(3,4) = BVE(3,4) AVE(3,5) = BVE(3,5) $ AVE(4,1) = BVE(4,1) $ AVE(4,2) = BVE(4,2) AVE(4,3) = BVE(4,3) $ AVE(4,4) = BVE(4,4) $ AVE(4,5) = BVE(4,5)
End $ " of Discrete NNeuw"End $ " of Dynamic "End $ " of Program "
'Fichero de comandos para el entrenamiento de la RNE'
'---Parametros del sliding'SET k2=1.72 $ SET K3=25
'---Parametros de la red neuronal'
SET ts=1.0e-3 $ SET tau=10.0e-3 $ SET taus=1.0e-3
SET landa = 1SET Ron = 0.01SET aa = 0.8SET Vg = 15SET px = 0.1
'---Condiciones iniciales'SET qe =0 $ SET iic=0 $ SET wic=0SET qic=0 $ SET Kic=0 $ SET e=0
'---Coeficientes de la referencia variable'
SET As0=0 $ SET As1=60 $ SET As2=70SET As3=70 $ SET As4=-70
SET wo1=0.2SET wo2=0.1SET wo3=0.333333SET wo4=0.8
'----- Parametros de entrenamiento On line'
ACTION 'var'=11,'val'=0.3,'loc'=MoACTION 'var'=16,'val'=0.1,'loc'=MoACTION 'var'=21,'val'=0.1,'loc'=MoACTION 'var'=27,'val'=0.2,'loc'=MoACTION 'var'=31,'val'=0.3,'loc'=MoACTION 'var'=35,'val'=0.4,'loc'=MoACTION 'var'=41,'val'=0.2,'loc'=MoACTION 'var'=75,'val'=0.4,'loc'=MoACTION 'var'=81,'val'=0.3,'loc'=MoACTION 'var'=85,'val'=0.1,'loc'=MoACTION 'var'=94,'val'=0.2,'loc'=MoACTION 'var'=100,'val'=0.4,'loc'=MoACTION 'var'=110,'val'=0.1,'loc'=MoACTION 'var'=140,'val'=0.4,'loc'=MoACTION 'var'=150,'val'=0.2,'loc'=Mo
'---Parametros de simulacion'SET Tstp=199.99SET Cint=0.1SET Ialg=4SET Nstp=1SET Maxt=1.0e-3
PREPAR T,q,qe,Ref,q,e,we,ve,Mo,koutput/NCIOUT = 10 t,q,qe,ve,we,e
'Fichero de comandos para diferentes ángulos de referencia''y diferentes masas de carga sin adaptación de los pesos'
'---Parametros del sliding'SET k2=1.72 $ SET K3=25'---Parametros de la red neuronal'SET ts=1.0e-3 $ SET tau=10.0e-3 $ SET taus=1.0e-3SET landa = 1SET Ron = 0 !Inhibición del aprendizajeSET aa = 0SET Vg = 15SET px = 0.1'---Condiciones iniciales'SET qe =0 $ SET iic=0 $ SET wic=0SET qic=0 $ SET Kic=0 $ SET e=0'---Coeficientes de la referencia variable'SET As0=0 $ SET As1=0 $ SET As2=0SET As3=0 $ SET As4=0
'----- Parametros de entrenamiento On line'ACTION 'var'=6,'val'=157.5,'loc'=As0ACTION 'var'=11,'val'=0.3,'loc'=MoACTION 'var'=12,'val'=120,'loc'=As0ACTION 'var'=16,'val'=0.1,'loc'=MoACTION 'var'=18,'val'=90,'loc'=As0ACTION 'var'=21,'val'=0.1,'loc'=MoACTION 'var'=24,'val'=60,'loc'=As0ACTION 'var'=27,'val'=0.2,'loc'=MoACTION 'var'=30,'val'=30,'loc'=As0ACTION 'var'=31,'val'=0.3,'loc'=MoACTION 'var'=35,'val'=0,'loc'=As0ACTION 'var'=35,'val'=0.4,'loc'=MoACTION 'var'=41,'val'=0.2,'loc'=MoACTION 'var'=45,'val'=-100,'loc'=As0ACTION 'var'=75,'val'=0.4,'loc'=MoACTION 'var'=81,'val'=0.3,'loc'=MoACTION 'var'=85,'val'=0.1,'loc'=MoACTION 'var'=94,'val'=0.2,'loc'=MoACTION 'var'=100,'val'=0.4,'loc'=MoACTION 'var'=90,'val'=40,'loc'=As0ACTION 'var'=110,'val'=0.1,'loc'=MoACTION 'var'=130,'val'=0,'loc'=As0ACTION 'var'=140,'val'=-20,'loc'=As0ACTION 'var'=140,'val'=0.4,'loc'=MoACTION 'var'=150,'val'=0.2,'loc'=Mo
'---Parametros de simulacion'SET Tstp=199.99SET Cint=0.1SET Ialg=4SET Nstp=1SET Maxt=1.0e-3
PREPAR T,q,qe,Ref,q,e,we,ve,Mo,koutput/NCIOUT = 10 t,q,qe,ve,we,e
4.5.3. Resultados del entrenamiento de la RNE
A continuación se muestran los resultados producto de la ejecución del programa.
Figura 4.13a: Error de entrenamiento en el intervalo 2000-3000 segundos
Figura 4.13b: Evolución del peso WE(4) en el intervalo 2000-3000 segundos
Tras entrenar la red 3000 segundos, los valores de los pesos obtenidos son lossiguientes:
VE(1,1)= 0.06715160 $ VE(2,1)= 0.01771000 $ VE(3,1)= 0.05172040
VE(4,1)= 0.07137170 $ VE(1,2)= 0.06526430 $ VE(2,2)= 0.09780790
VE(3,2)= 0.05757490 $ VE(4,2)=-0.05503440 $ VE(1,3)= 0.06122120
VE(2,3)=-0.05513160 $ VE(3,3)= 0.00406387 $ VE(4,3)= 0.03685420
VE(1,4)=-0.43728300 $ VE(2,4)=-0.60673600 $ VE(3,4)= 0.46002200
VE(4,4)= 0.61908000 $ VE(1,5)= 0.34178300 $ VE(2,5)=-0.06142720
VE(3,5)=-0.39220000 $ VE(4,5)= 0.16299000 $ WE(1)=-3.67639000
WE(2)=-4.73977000 $ WE(3)= 3.62300000 $ WE(4)= 4.68183000
Dejando los valores fijos se emula el comportamiento de la red ante diferentes
entradas con masa de carga variable obteniéndose los siguientes resultados
Figura 4.14a: Señal emulada sin backpropagación
tras 3000 segundos de entrenamiento
Figura 4.14b: Masa de carga (kg)
Figura 4.14c: Error de la señal anterior
Figura 4.15a: Error de entrenamiento en el intervalo 8000-9000 segundos
Figura 4.15b: Evolución de la constante WE(4)
en el intervalo 8000-9000 segundos
Tras entrenar la red 9000 segundos, los valores de los pesos obtenidos son lossiguientes:
VE(1,1)= 0.06715160 $ VE(2,1)= 0.01771000 $ VE(3,1)= 0.05172040
VE(4,1)= 0.07137170 $ VE(1,2)= 0.06526430 $ VE(2,2)= 0.09780790
VE(3,2)= 0.05757490 $ VE(4,2)=-0.05503440 $ VE(1,3)= 0.06122120
VE(2,3)=-0.05513160 $ VE(3,3)= 0.00406387 $ VE(4,3)= 0.03685420
VE(1,4)=-0.60711600 $ VE(2,4)=-0.49308700 $ VE(3,4)= 0.63920400
VE(4,4)= 0.45708700 $ VE(1,5)= 0.38440100 $ VE(2,5)= 0.22106800
VE(3,5)=-0.43049100 $ VE(4,5)=-0.12702600 $ WE(1)=-3.91803000
WE(2)=-4.98159000 $ WE(3)= 3.92082000 $ WE(4)= 4.97454000
Dejando los valores anteriores fijos tenemos
Figura 4.16a: Señal emulada sin backpropagación tras 9000 segundos deentrenamiento
Figura 4.16a: Error de posición de la señal anterior
Figura 4.17a: Error de entrenamiento intervalo 14000-15000 segundos
Figura 4.17b: Evolución de la constante
WE(4) en el intervalo 14000-15000 segundos
Tras entrenar la red 15000 segundos, los valores de los pesos obtenidos son lossiguientes:
VE(1,1)= 0.06715160 $ VE(2,1)= 0.01771000 $ VE(3,1)= 0.05172040
VE(4,1)= 0.07137170 $ VE(1,2)= 0.06526430 $ VE(2,2)= 0.09780790
VE(3,2)= 0.05757490 $ VE(4,2)=-0.05503440 $ VE(1,3)= 0.06122120
VE(2,3)=-0.05513160 $ VE(3,3)= 0.00406387 $ VE(4,3)= 0.03685420
VE(1,4)=-0.61920200 $ VE(2,4)=-0.50128200 $ VE(3,4)= 0.65278200
VE(4,4)= 0.44381800 $ VE(1,5)= 0.39344400 $ VE(2,5)= 0.22533300
VE(3,5)=-0.44091100 $ VE(4,5)=-0.14538800 $ WE(1)=-3.97656000
WE(2)=-5.04000000 $ WE(3)= 3.98002000 $ WE(4)= 5.03514000
Dejando los valores anteriores fijos tenemos
Figura 4.18a: Señal emulada sin backpropagación
tras 15000 segundos de entrenamiento
Figura 4.18b: Error de posición de la señal anterior
4.5.4. Programa de entrenamiento de la Red Neuronal Controladora
El esquema del entrenamiento definitivo para la generación de la variable de
entrada a la planta k se mostró en la figura 4.8. A continuación se describe el diagrama
de bloques del entrenamiento de la Red Neuronal Controladora, en el que se ha obviado
la parte referente al entrenamiento de la RNE ya referida en la figura 4.11.
Figura 4.19: Diagrama de bloques del entrenamiento de la RNC.
Algoritmo de entrenamiento de la Red Neuronal Controladora (RNC)
Paso 1
Se elige una constante de aprendizaje η > 0 y se pone una cota a los errores de
las señales deseadas en las salidas (Emax).
Los pesos wc y vc de la RNC son inicializados con pequeños valores
aleatorios. wc es de dimensión [1x4], mientras que vc es de dimensión [4x5].
También se inicializa el error de salida: EE = 0
Paso 2
El ciclo de entrenamiento empieza aquí. Al producirse un muestreo, se
inicializa el vector de entrada y, a partir del mismo, las salidas de las dos capas de
neuronas de la red son computadas.
El vector de entrada xc es de dimensión [5x1].
[ ] [ ] [ ] [ ] [ ]
[ ] [ ]
Netc vc xc i
K wc j yc j
e nrtc i
j
4 1 4 5 5 11
11 2 3 4
1
4
× = × ⋅ × → =+
=
= ⋅
− ⋅
=∑
yc para i λ
, , ,
Paso 3
Computación de los valores de los errores. ( )EE EE f q+ = + ⋅ −12
2Re
Paso 4
Computación de los vectores de error de señal δ O (capa de salida) y δ C (capa
intermedia).
El error a la salida es (Ref-q) que se backpropaga a través de la RNE.
Capa de salida:
[ ] [ ] [ ] [ ]( )δ λ λO
j
f q we j ve j ye ie= − ⋅ ⋅ ⋅ ⋅ ⋅=
⋅∑(Re ) ,1
42
1 - Nete i
Capa escondida:
[ ] [ ] [ ]( ) [ ]δ λ δλC Oi yc i wc i ara ie= ⋅ ⋅ ⋅ ⋅ =⋅- Netc i p
21 2 3 4, , ,
Paso 5
Se ajustan los pesos de la capa de salida.
[ ] [ ] [ ]wc i wc i yc i ara iO+ = + ⋅ ⋅ =η δ p 1 2 3 4, , ,
Paso 6
Se ajustan los pesos de la capa escondida.
[ ] [ ] [ ] [ ]vc vc xcCt+ × = × + ⋅ × ⋅ ×4 5 4 5 4 5 1 5η δ
Paso 7
Si no ha pasado toda la secuencia de referencia, cuando se produce un nuevo
muestreo se va al paso 2. Si ya pasó, se va al paso 8.
Paso 8
El ciclo de entrenamiento se ha completado. Si el error ha alcanzado cotas
inferiores al Error máximo, la sesión de entrenamiento se da por finalizada. El valor de
los pesos final será el que se utilizará definitivamente en el sistema.
Si el error supera al Error máximo permitido, entonces EE = 0 , y se inicia un
nuevo ciclo de entrenamiento desde el paso 2 pasando desde el inicio la secuencia de
entrenamiento, con valores iniciales de los pesos iguales a los finales del anterior ciclo
de entrenamiento.
La señal de referencia utilizada en el entrenamiento es del mismo tipo que la
empleada para el entrenamiento de la Red Neuronal Emuladora.
Figura 4.20: Señal de referencia en el entrenamiento de la RNC
A continuación se muestra el programa ACSL utilizado para la simulación del
entrenamiento.
‘Program Entrenamiento de las redes controladora y emuladora’Initial
real VE(4,5),WE(4),AVE(4,5),AWE(4),BVE(4,5),BWE(4) real VC(4,5),WC(4),AVC(4,5),AWC(4),BVC(4,5),BWC(4)
"-------Constantes de la planta"
Constant J=1.625e-3,m0=0.506,Mo=0.434,Lo=0.305 Constant Ro=0.023,Bo=16.25e-3,L=25e-3,R=5 Constant Kt=0.9,Kb=0.9,G=9.8,Vg=15
M=J/Kt+m0*Lo*Lo/(3*Kt)+Mo*Lo*Lo/Kt+2*Mo*Ro*Ro/(5*Kt) N=m0*Lo*G/(2*Kt)+Mo*Lo*G/Kt B=Bo/Kt
"-------coeficientes del sliding" Constant dk=2
"------Coeficientes de las ecuaciones de estado" a11=-R/L a12=-Kb/L dimension b1(2) b1(1)=Vg/L $ b1(2)=-Vg/L
ee=0 eee=0
"-----Periodo de muestreo" Constant ts=1.0e-3 tsamp=ts
"-----Constantes de tiempo del filtro reconstructor y de salida" Constant tau=10.0e-3,taus=1.0e-3
"-----Condiciones iniciales de las variables de estado continuas" Constant iic=0,wic=0,qic=0,Kic=0
"-----Condicion inicial del comparador con histeresis" Integer p p=1 s=iic+k2*wic+k3*qic-Kic if(s.GT.dk) p=2
"-----Coeficientes de las redes neuronales" Constant landa=0.0001,landac=0.0001,Ron=0.01,Ronc=10,aa=0.8
"-----Condiciones iniciales de las variables discretas de las NN" Dini=Kic D=Dini
Dp=Dini qp=qic qm=qic
"-----Condiciones iniciales de los pesos" "------De la red emuladora"
BWE(1) = 0 $ BWE(2) = 0 $ BWE(3) = 0 $ BWE(4) = 0 BVE(1,1) = 0 $ BVE(1,2) = 0 $ BVE(1,3) = 0 $ BVE(1,4) = 0 BVE(1,5) = 0 $ BVE(2,1) = 0 $ BVE(2,2) = 0 $ BVE(2,3) = 0 BVE(2,4) = 0 $ BVE(2,5) = 0 $ BVE(3,1) = 0 $ BVE(3,2) = 0 BVE(3,3) = 0 $ BVE(3,4) = 0 $ BVE(3,5) = 0 $ BVE(4,1) = 0 BVE(4,2) = 0 $ BVE(4,3) = 0 $ BVE(4,4) = 0 $ BVE(4,5) = 0
AWE(1) = 0 $ AWE(2) = 0 $ AWE(3) = 0 $ AWE(4) = 0 AVE(1,1) = 0 $ AVE(1,2) = 0 $ AVE(1,3) = 0 $ AVE(1,4) = 0 AVE(1,5) = 0 $ AVE(2,1) = 0 $ AVE(2,2) = 0 $ AVE(2,3) = 0 AVE(2,4) = 0 $ AVE(2,5) = 0 $ AVE(3,1) = 0 $ AVE(3,2) = 0 AVE(3,3) = 0 $ AVE(3,4) = 0 $ AVE(3,5) = 0 $ AVE(4,1) = 0 AVE(4,2) = 0 $ AVE(4,3) = 0 $ AVE(4,4) = 0 $ AVE(4,5) = 0
BWC(1) = 0 $ BWC(2) = 0 $ BWC(3) = 0 $ BWC(4) = 0 BVC(1,1) = 0 $ BVC(1,2) = 0 $ BVC(1,3) = 0 $ BVC(1,4) = 0 BVC(1,5) = 0 $ BVC(2,1) = 0 $ BVC(2,2) = 0 $ BVC(2,3) = 0 BVC(2,4) = 0 $ BVC(2,5) = 0 $ BVC(3,1) = 0 $ BVC(3,2) = 0 BVC(3,3) = 0 $ BVC(3,4) = 0 $ BVC(3,5) = 0 $ BVC(4,1) = 0 BVC(4,2) = 0 $ BVC(4,3) = 0 $ BVC(4,4) = 0 $ BVC(4,5) = 0
AWC(1) = 0 $ AWC(2) = 0 $ AWC(3) = 0 $ AWC(4) = 0 AVC(1,1) = 0 $ AVC(1,2) = 0 $ AVC(1,3) = 0 $ AVC(1,4) = 0 AVC(1,5) = 0 $ AVC(2,1) = 0 $ AVC(2,2) = 0 $ AVC(2,3) = 0 AVC(2,4) = 0 $ AVC(2,5) = 0 $ AVC(3,1) = 0 $ AVC(3,2) = 0 AVC(3,3) = 0 $ AVC(3,4) = 0 $ AVC(3,5) = 0 $ AVC(4,1) = 0 AVC(4,2) = 0 $ AVC(4,3) = 0 $ AVC(4,4) = 0 $ AVC(4,5) = 0
Constant px=0.1
VC(1,1)=UNIF(-px,px) $ VC(2,1)=UNIF(-px,px) VC(3,1)=UNIF(-px,px) $ VC(4,1)=UNIF(-px,px) VC(1,2)=UNIF(-px,px) $ VC(2,2)=UNIF(-px,px) VC(3,2)=UNIF(-px,px) $ VC(4,2)=UNIF(-px,px) VC(1,3)=UNIF(-px,px) $ VC(2,3)=UNIF(-px,px) VC(3,3)=UNIF(-px,px) $ VC(4,3)=UNIF(-px,px) VC(1,4)=UNIF(-px,px) $ VC(2,4)=UNIF(-px,px) VC(3,4)=UNIF(-px,px) $ VC(4,4)=UNIF(-px,px) VC(1,5)=UNIF(-px,px) $ VC(2,5)=UNIF(-px,px) VC(3,5)=UNIF(-px,px) $ VC(4,5)=UNIF(-px,px) WC(1)=UNIF(-px,px) $ WC(2)=UNIF(-px,px) WC(3)=UNIF(-px,px) $ WC(4)=UNIF(-px,px)
VE(1,1)= 0.06715160 $ VE(2,1)= 0.01771000 VE(3,1)= 0.05172040 $ VE(4,1)= 0.07137170 VE(1,2)= 0.06526430 $ VE(2,2)= 0.09780790 VE(3,2)= 0.05757490 $ VE(4,2)=-0.05503440 VE(1,3)= 0.06122120 $ VE(2,3)=-0.05513160
VE(3,3)= 0.00406387 $ VE(4,3)= 0.03685420 VE(1,4)=-0.65470300 $ VE(2,4)=-0.51884900 VE(3,4)= 0.69511300 $ VE(4,4)= 0.45078500 VE(1,5)= 0.42692600 $ VE(2,5)= 0.29496100 VE(3,5)=-0.46774700 $ VE(4,5)=-0.22592300 WE(1)=-4.43489000 $ WE(2)=-5.47967000 WE(3)= 4.42495000 $ WE(4)= 5.49451000
"-----Constantes de la referencia variable" Constant As0=1,As1=1,As2=1,As3=1,As4=1 Constant wo1=1,wo2=0.5,wo3=0.3333333,wo4=0.2 Ref=As0+As1*sin(wo1*t)+As2*sin(wo2*t)+As3*sin(wo3*t)+As4*sin(wo4*t)End $ "de initial"
Dynamic "------Intervalo de comunicación" Cinterval Cint = 1.0e-3 "-------Condición para terminar" Constant Tstp = 4 Termt(T .GE. Tstp)
Derivative "-------Algoritmo de integración y tamaño de paso " Algorithm Ialg = 4 Nsteps Nstp = 1 Maxterval Maxt = 1.0e-3
"-------Variables auxiliares" M=J/Kt+m0*Lo*Lo/(3*Kt)+Mo*Lo*Lo/Kt+2*Mo*Ro*Ro/(5*Kt) N=m0*Lo*G/(2*Kt)+Mo*Lo*G/Kt
"-------Ecuaciones de estado" i=INTEG(a11*i+a12*w +b1(p),iic) w=INTEG((i-B*w-N*sin(qr))/M ,wic) qr=INTEG( w ,qic)
"-------Control" K=REALPL(tau,D,Kic)
Ref=As0+As1*sin(wo1*t)+As2*sin(wo2*t)+As3*sin(wo3*t)+As4*sin(wo4*t)
s=i+k2*w+k3*qr-K q=REALPL(taus,qr)
"-------Cambios de subintervalo" SCHEDULE aOn .XN. s+dk SCHEDULE aOff .XP. s-dkEnd $ " of Derivative "
Discrete aOn p=1End $ " of Discrete aOn"Discrete aOff p=2End $ " of Discrete aOff"
Discrete NN INTERVAL tsamp= 1.0e-3
Dpp=Dp Dp=D qpp=qp qp=qm qm=q SCHEDULE NNcse .AT. t+0.0End $ " of Discrete NN"
Discrete NNcse
netc1 = VC(1,1)*Ref+VC(1,2)*qp+VC(1,3)*qpp+VC(1,4)*Dp+VC(1,5)*Dppnetc2 = VC(2,1)*Ref+VC(2,2)*qp+VC(2,3)*qpp+VC(2,4)*Dp+VC(2,5)*Dppnetc3 = VC(3,1)*Ref+VC(3,2)*qp+VC(3,3)*qpp+VC(3,4)*Dp+VC(3,5)*Dppnetc4 = VC(4,1)*Ref+VC(4,2)*qp+VC(4,3)*qpp+VC(4,4)*Dp+VC(4,5)*Dpp
yc1 = 1/(1+EXP(-landac*netc1)) yc2 = 1/(1+EXP(-landac*netc2)) yc3 = 1/(1+EXP(-landac*netc3)) yc4 = 1/(1+EXP(-landac*netc4))
ypc1 = (landac*EXP(-landac*netc1))*yc1*yc1 ypc2 = (landac*EXP(-landac*netc2))*yc2*yc2 ypc3 = (landac*EXP(-landac*netc3))*yc3*yc3 ypc4 = (landac*EXP(-landac*netc4))*yc4*yc4
D = WC(1)*yc1+WC(2)*yc2+WC(3)*yc3+WC(4)*yc4
SCHEDULE NNese .AT. t+0.0end $ "de NNcse"
Discrete NNese nete1=VE(1,1)*D+VE(1,2)*Dp+VE(1,3)*Dpp+VE(1,4)*qp+VE(1,5)*qpp nete2=VE(2,1)*D+VE(2,2)*Dp+VE(2,3)*Dpp+VE(2,4)*qp+VE(2,5)*qpp nete3=VE(3,1)*D+VE(3,2)*Dp+VE(3,3)*Dpp+VE(3,4)*qp+VE(3,5)*qpp nete4=VE(4,1)*D+VE(4,2)*Dp+VE(4,3)*Dpp+VE(4,4)*qp+VE(4,5)*qpp
ye1=1/(1+EXP(-landa*nete1)) ye2=1/(1+EXP(-landa*nete2)) ye3=1/(1+EXP(-landa*nete3)) ye4=1/(1+EXP(-landa*nete4))
ype1=(landa*EXP(-landa*nete1))*ye1*ye1 ype2=(landa*EXP(-landa*nete2))*ye2*ye2 ype3=(landa*EXP(-landa*nete3))*ye3*ye3 ype4=(landa*EXP(-landa*nete4))*ye4*ye4
qe=WE(1)*ye1+WE(2)*ye2+WE(3)*ye3+WE(4)*ye4 e=q-qe
ee=WE(1)*ype1*VE(1,1)+WE(2)*ype2*VE(2,1)+WE(3)*ype3*VE(3,1)+WE(4)*ype4*VE(4,1) eee=Ref-q eb=eee*ee
SCHEDULE NNeuw .AT. t+0.0
end $ "de NNese"
Discrete NNeuw BWE(1)=Ron*e*ye1 BWE(2)=Ron*e*ye2 BWE(3)=Ron*e*ye3 BWE(4)=Ron*e*ye4 BVE(1,1)=Ron*D*e*WE(1)*ype1 BVE(1,2)=Ron*Dp*e*WE(1)*ype1 BVE(1,3)=Ron*Dpp*e*WE(1)*ype1 BVE(1,4)=Ron*qp*e*WE(1)*ype1 BVE(1,5)=Ron*qpp*e*WE(1)*ype1 BVE(2,1)=Ron*D*e*WE(2)*ype2 BVE(2,2)=Ron*Dp*e*WE(2)*ype2 BVE(2,3)=Ron*Dpp*e*WE(2)*ype2 BVE(2,4)=Ron*qp*e*WE(2)*ype2 BVE(2,5)=Ron*qpp*e*WE(2)*ype2 BVE(3,1)=Ron*D*e*WE(3)*ype3 BVE(3,2)=Ron*Dp*e*WE(3)*ype3 BVE(3,3)=Ron*Dpp*e*WE(3)*ype3 BVE(3,4)=Ron*qp*e*WE(3)*ype3 BVE(3,5)=Ron*qpp*e*WE(3)*ype3 BVE(4,1)=Ron*D*e*WE(4)*ype4 BVE(4,2)=Ron*Dp*e*WE(4)*ype4 BVE(4,3)=Ron*Dpp*e*WE(4)*ype4 BVE(4,4)=Ron*qp*e*WE(4)*ype4 BVE(4,5)=Ron*qpp*e*WE(4)*ype4
WE(1) = WE(1)+BWE(1)+aa*AWE(1) WE(2) = WE(2)+BWE(2)+aa*AWE(2) WE(3) = WE(3)+BWE(3)+aa*AWE(3) WE(4) = WE(4)+BWE(4)+aa*AWE(4) VE(1,1) = VE(1,1)+BVE(1,1)+aa*AVE(1,1) VE(1,2) = VE(1,2)+BVE(1,2)+aa*AVE(1,2) VE(1,3) = VE(1,3)+BVE(1,3)+aa*AVE(1,3) VE(1,4) = VE(1,4)+BVE(1,4)+aa*AVE(1,4) VE(1,5) = VE(1,5)+BVE(1,5)+aa*AVE(1,5) VE(2,1) = VE(2,1)+BVE(2,1)+aa*AVE(2,1) VE(2,2) = VE(2,2)+BVE(2,2)+aa*AVE(2,2) VE(2,3) = VE(2,3)+BVE(2,3)+aa*AVE(2,3) VE(2,4) = VE(2,4)+BVE(2,4)+aa*AVE(2,4) VE(2,5) = VE(2,5)+BVE(2,5)+aa*AVE(2,5) VE(3,1) = VE(3,1)+BVE(3,1)+aa*AVE(3,1) VE(3,2) = VE(3,2)+BVE(3,2)+aa*AVE(3,2) VE(3,3) = VE(3,3)+BVE(3,3)+aa*AVE(3,3)
VE(3,4) = VE(3,4)+BVE(3,4)+aa*AVE(3,4) VE(3,5) = VE(3,5)+BVE(3,5)+aa*AVE(3,5) VE(4,1) = VE(4,1)+BVE(4,1)+aa*AVE(4,1) VE(4,2) = VE(4,2)+BVE(4,2)+aa*AVE(4,2) VE(4,3) = VE(4,3)+BVE(4,3)+aa*AVE(4,3) VE(4,4) = VE(4,4)+BVE(4,4)+aa*AVE(4,4) VE(4,5) = VE(4,5)+BVE(4,5)+aa*AVE(4,5)
AWE(1) = BWE(1) $ AWE(2) = BWE(2) $ AWE(3) = BWE(3) AWE(4) = BWE(4) $ AVE(1,1) = BVE(1,1) $ AVE(1,2) = BVE(1,2) AVE(1,3) = BVE(1,3) $ AVE(1,4) = BVE(1,4) $ AVE(1,5) = BVE(1,5) AVE(2,1) = BVE(2,1) $ AVE(2,2) = BVE(2,2) $ AVE(2,3) = BVE(2,3) AVE(2,4) = BVE(2,4) $ AVE(2,5) = BVE(2,5) $ AVE(3,1) = BVE(3,1) AVE(3,2) = BVE(3,2) $ AVE(3,3) = BVE(3,3) $ AVE(3,4) = BVE(3,4) AVE(3,5) = BVE(3,5) $ AVE(4,1) = BVE(4,1) $ AVE(4,2) = BVE(4,2) AVE(4,3) = BVE(4,3) $ AVE(4,4) = BVE(4,4) $ AVE(4,5) = BVE(4,5)
SCHEDULE NNcuw .AT. t+0.0
End $ " of Discrete NNeuw"
Discrete NNcuw
BWC(1)=Ronc*eb*yc1 BWC(2)=Ronc*eb*yc2 BWC(3)=Ronc*eb*yc3 BWC(4)=Ronc*eb*yc4
BVC(1,1)=Ronc*Ref*eb*WC(1)*ypc1 BVC(1,2)=Ronc*qp*eb*WC(1)*ypc1 BVC(1,3)=Ronc*qpp*eb*WC(1)*ypc1 BVC(1,4)=Ronc*Dp*eb*WC(1)*ypc1 BVC(1,5)=Ronc*Dpp*eb*WC(1)*ypc1 BVC(2,1)=Ronc*Ref*eb*WC(2)*ypc2 BVC(2,2)=Ronc*qp*eb*WC(2)*ypc2 BVC(2,3)=Ronc*qpp*eb*WC(2)*ypc2 BVC(2,4)=Ronc*Dp*eb*WC(2)*ypc2 BVC(2,5)=Ronc*Dpp*eb*WC(2)*ypc2 BVC(3,1)=Ronc*Ref*eb*WC(3)*ypc3 BVC(3,2)=Ronc*qp*eb*WC(3)*ypc3 BVC(3,3)=Ronc*qpp*eb*WC(3)*ypc3 BVC(3,4)=Ronc*Dp*eb*WC(3)*ypc3 BVC(3,5)=Ronc*Dpp*eb*WC(3)*ypc3 BVC(4,1)=Ronc*Ref*eb*WC(4)*ypc4 BVC(4,2)=Ronc*qp*eb*WC(4)*ypc4 BVC(4,3)=Ronc*qpp*eb*WC(4)*ypc4 BVC(4,4)=Ronc*Dp*eb*WC(4)*ypc4 BVC(4,5)=Ronc*Dpp*eb*WC(4)*ypc4
WC(1) = WC(1)+BWC(1)+aa*AWC(1) WC(2) = WC(2)+BWC(2)+aa*AWC(2) WC(3) = WC(3)+BWC(3)+aa*AWC(3) WC(4) = WC(4)+BWC(4)+aa*AWC(4)
VC(1,1) = VC(1,1)+BVC(1,1)+aa*AVC(1,1) VC(1,2) = VC(1,2)+BVC(1,2)+aa*AVC(1,2) VC(1,3) = VC(1,3)+BVC(1,3)+aa*AVC(1,3) VC(1,4) = VC(1,4)+BVC(1,4)+aa*AVC(1,4)
VC(1,5) = VC(1,5)+BVC(1,5)+aa*AVC(1,5) VC(2,1) = VC(2,1)+BVC(2,1)+aa*AVC(2,1) VC(2,2) = VC(2,2)+BVC(2,2)+aa*AVC(2,2) VC(2,3) = VC(2,3)+BVC(2,3)+aa*AVC(2,3) VC(2,4) = VC(2,4)+BVC(2,4)+aa*AVC(2,4) VC(2,5) = VC(2,5)+BVC(2,5)+aa*AVC(2,5) VC(3,1) = VC(3,1)+BVC(3,1)+aa*AVC(3,1) VC(3,2) = VC(3,2)+BVC(3,2)+aa*AVC(3,2) VC(3,3) = VC(3,3)+BVC(3,3)+aa*AVC(3,3) VC(3,4) = VC(3,4)+BVC(3,4)+aa*AVC(3,4) VC(3,5) = VC(3,5)+BVC(3,5)+aa*AVC(3,5) VC(4,1) = VC(4,1)+BVC(4,1)+aa*AVC(4,1) VC(4,2) = VC(4,2)+BVC(4,2)+aa*AVC(4,2) VC(4,3) = VC(4,3)+BVC(4,3)+aa*AVC(4,3) VC(4,4) = VC(4,4)+BVC(4,4)+aa*AVC(4,4) VC(4,5) = VC(4,5)+BVC(4,5)+aa*AVC(4,5)
AWC(1) = BWC(1) $ AWC(2) = BWC(2) AWC(3) = BWC(3) $ AWC(4) = BWC(4)
AVC(1,1) = BVC(1,1) $ AVC(1,2) = BVC(1,2) AVC(1,3) = BVC(1,3) $ AVC(1,4) = BVC(1,4) AVC(1,5) = BVC(1,5) $ AVC(2,1) = BVC(2,1) AVC(2,2) = BVC(2,2) $ AVC(2,3) = BVC(2,3) AVC(2,4) = BVC(2,4) $ AVC(2,5) = BVC(2,5) AVC(3,1) = BVC(3,1) $ AVC(3,2) = BVC(3,2) AVC(3,3) = BVC(3,3) $ AVC(3,4) = BVC(3,4) AVC(3,5) = BVC(3,5) $ AVC(4,1) = BVC(4,1) AVC(4,2) = BVC(4,2) $ AVC(4,3) = BVC(4,3) AVC(4,4) = BVC(4,4) $ AVC(4,5) = BVC(4,5)
End $ " of Discrete NNcuw"End $ " of Dynamic "End $ " of Program "
'Fichero de comandos de ejecucion de una simulacion con ACSL'
SET px = 10SET Ron = 0.5SET Ronc = 10SET aa = 0.8SET landa = 0.0001SET landac = 0.0001
'---Coeficientes de la referencia variable'SET As0 = 0 $ SET As1 = 3 $ SET As2 = 3SET As3 = 3 $ SET As4 = -3SET ype1 = 0 $ SET ype2=0
SET ype3 = 0 $ SET ype4=0SET ye1 = 0 $ SET ye2=0SET ye3 = 0 $ SET ye4=0SET yc1 = 0 $ SET yc2=0SET yc3 = 0 $ SET yc4=0SET e = 0 $ SET eb=0
'---Condiciones iniciales'SET qe =0SET iic =0SET wic=0SET qic =0SET Kic=0SET e =0SET eb =0SET wo1= 0.2 $ SET wo2= 0.1SET wo3= 0.333333 $ SET wo4= 0.8 $ SET Mo =0.1
'----- Parametros de entrenamiento On line'ACTION 'var'=15,'val'=0.4,'loc'=MoACTION 'var'=25,'val'=0.3,'loc'=MoACTION 'var'=45,'val'=0.5,'loc'=MoACTION 'var'=55,'val'=0.1,'loc'=MoACTION 'var'=75,'val'=0.5,'loc'=MoACTION 'var'=85,'val'=0.2,'loc'=MoACTION 'var'=95,'val'=0.4,'loc'=MoACTION 'var'=105,'val'=0.15,'loc'=MoACTION 'var'=135,'val'=0.4,'loc'=MoACTION 'var'=155,'val'=0.5,'loc'=MoACTION 'var'=165,'val'=0.25,'loc'=MoACTION 'var'=185,'val'=0.4,'loc'=Mo
'---Parametros de simulacion'
SET Tstp=199.99SET Cint=0.1SET Ialg=4SET Nstp=1SET Maxt=1.0e-3PREPAR T,qr,qe,Ref,q,e,we,ve,Mo,eb,wc,vc,eee,K,s,poutput/NCIOUT = 10 t,Ref,q,ve,we,vc,wc,eee
4.5.5. Resultados del entrenamiento de la Red Neuronal Controladora
Para tener buenos resultados se deben entrenar las redes el mayor tiempo
posible. Tras 20000 segundos, el error disminuye considerablemente, como se aprecia a
la vista del error obtenido entre los 18000 y 20000 segundos.
Figura 4.20: Error de entrenamiento de la RNC
en el intervalo 4000-6000 segundos
Figura 4.21: Error de entrenamiento de la RNC
en el intervalo 18000-20000 segundos
Finalmente, se pone a prueba el control adaptativo bajo diferentes referencias
cuadradas y diferentes masas de carga con los valores iniciales de las constantes
resultantes del entrenamiento, obteniendo resultados satisfactorios (desaparición de
sobreimpulsos).
4.5.6. Resultados del control adaptativo final
Los valores de los pesos iniciales son:
VE(1,1)=-2.39674000 VE(2,1)=-2.31934000 VE(3,1)= 2.45002000
VE(4,1)= 2.40680000 VE(1,2)=-3.39197000 VE(2,2)=-3.44034000
VE(3,2)= 3.45413000 VE(4,2)= 3.46337000 VE(1,3)=-4.43519000
VE(2,3)=-4.84997000 VE(3,3)= 4.44843000 VE(4,3)= 4.79546000
VE(1,4)=-1.11937000 VE(2,4)=-1.08134000 VE(3,4)= 1.15306000
VE(4,4)= 1.01705000 VE(1,5)=-0.14473300 VE(2,5)=-0.40080800
VE(3,5)= 0.09768700 VE(4,5)= 0.47327000 WE(1)=-10.5485000
WE(2)=-12.4164000 WE(3)= 10.6440000 WE(4)= 12.2977000
VC(1,1)=-27.7248000 VC(2,1)= 42.9100000 VC(3,1)=-137.526000
VC(4,1)= 126.116000 VC(1,2)= 6.11488000 VC(2,2)=-14.2808000
VC(3,2)= 25.2996000 VC(4,2)=-25.6068000 VC(1,3)= 12.2707000
VC(2,3)=-5.74989000 VC(3,3)= 27.6158000 VC(4,3)=-13.5898000
VC(1,4)=-23.4810000 VC(2,4)= 39.7378000 VC(3,4)=-54.4874000
VC(4,4)= 51.5362000 VC(1,5)=-15.8675000 VC(2,5)= 1.85947000
VC(3,5)=-2.21038000 VC(4,5)= 2.33904000 WC(1)=-87.4039000
WC(2)= 107.584000 WC(3)=-222.943000 WC(4)= 202.562000
Figura 4.22a: Posición angular del manipulador
ante variaciones de Ref y/o Mo
Figura 4.22b: Masa de carga utilizada en el control final
Figura 4.22c: Variable K generada por la RNC
Figura 4.22c: Error Ref-q de la señal anterior
5.- Conclusiones
El control en modo de deslizamiento produce un resultado satisfactorio en
régimen estacionario. Aunque no evita los rebasamientos, es muy útil puesto que reduce
el orden del sistema a controlar. Partiendo del sistema reducido de segundo orden, el
objetivo del proyecto es la búsqueda de un control capaz de actuar en las transiciones
entre posiciones, teniendo en cuenta que la función de transferencia del sistema no es
lineal y además depende de la masa de carga.
Las redes neuronales son capaces de aprender el comportamiento no lineal de
la planta, de manera que entrenadas correctamente puedan proporcionar la variable K
adecuada en cada instante. El entrenamiento de la Red Emuladora resulta satisfactorio
puesto que la precisión de 15 grados dejando los pesos fijos se corresponde con el
límite de exactitud derivado del uso de una red con cuatro neuronas. En cuanto a la Red
Controladora, sin embargo, el entrenamiento resulta lento y complejo debido a varios
motivos. En primer lugar, el valor de la pendiente de las funciones de activación debe
ser mucho menor que en el caso del entrenamiento de la Red Emuladora fuera de linea
ya que es la única manera de poder propagar un error a través de la RNE hacia la RNC
suficientemente grande como para permitir la adaptación de sus pesos. En segundo
lugar, el número de pares entrada-salida que se le pasan a la red es infinito mientras que
existe una limitación en la capacidad de aprender de la red. Se probaron redes con más
neuronas pero aparece el problema de los mínimos locales descrito en el apartado 4.4. y
además el entrenamiento resulta aún más lento.
La elección de la constante de aprendizaje también es problemática. Un valor
grande de la misma lleva a unos valores de los pesos oscilatorios y muy dependientes de
la señal de entrenamiento. LLegados a este punto, se reduce la constante partiendo de
los valores finales del aprendizaje anterior. Los pesos se adaptan hasta llegar de nuevo
las oscilaciones pero la amplitud de las mismas ha disminuído. El proceso, que es muy
laborioso, se repite hasta llegar a cotas de error aceptables. Los valores de los pesos
hallados resultan ser adecuados como iniciales en el control adaptativo definitivo que
resulta satisfactorio. Los pesos de las redes se mueven en un margen de valores estrecho
debido a todo el entrenamiento previo. La implementación de este sistema es factible;
sin embargo, no se puede considerar que el sistema sea fiable porque quizás podría
darse una secuencia de referencia en la entrada que desentrenara la red o incluso que
desestabilizara el sistema.
6.- Bibliografía
1.- D.M.Dawson, J.J.Carroll, M.Schneider, “Integrator Backstepping Control
of a Bush DC Motor Turning a Robotic Load”, IEEE Trans. on Control Systems
Technology, Vol. 2, No 3, Sept 1994 pp.233-243
2.- Jacek M. Zurada, “Introduction to Artificial Neural Systems”
3.- R.Leyva, J.Calvente, R.Giral y L.Martínez, “Sliding-mode and Neural
Network control of a robotic manipulator driven by a permanent magnet DC motor”
4.- “Apuntes de control, ampliación de control y control en modo
deslizamiento”
5.- “Advanced continuos simulation language (ACSL) reference manual”,
Edition 10, 1991.