Proyecto Final Grupo No. 0 6 PDF

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA Fecha:
ESCUELA DE CIENCIAS BASICAS E INGENIERIAS Junio de 2010

PROGRAMA DE INGENIERIA ELECTRÓNICA Pág. 1 de 16
SISTEMAS AVANZADOS DE CONTROL
Universidad Nacional Abierta y a Distancia UNAD
GUIADO DE ROBOT CON UNA RED NEURONAL

ENTRENAMIENTO A PARTIR DE DATOS DE UN CONTROL
SUPERVISADO
PRESENTA
JAINSON POLO DE LA HOZ

COD: 72260767
AL INGENIERO
CARLOS VERA
VALLEDUPAR - COLOMBIA JUNIO DE 2010

1
Introducción
En el Trabajo Final , se aborda un problema completo de guiado de un móvil, buscando

como objetivo, que el controlador a implementar, “aprenda” a guiar al móvil, tal y como
lo hace una persona o un controlador supervisado.
Este tipo de control, normalmente no es abordable por un controlador clásico, y en
muchos casos, ni siquiera por un borroso o controlador por conductas, puesto que las
personas realizamos algunas acciones inconscientemente, y por tanto, no todo lo que se
realiza en un guiado, es un conocimiento que podamos transmitir.
Por tanto, se diseñará una red neuronal, y será entrenada, partiendo de los datos
registrados en uno o varios procesos de guiado supervisado (por una persona). Una vez
realizado el entrenamiento, la red será capaz de determinar las velocidades del móvil
(velocidad lineal y velocidad angular) de forma similar a como lo haría la persona que
ha realizado el guiado o la supervisión.
Para el desarrollo, entrenamiento y prueba del controlador, se trabajará bajo simulación
con Matlab, siendo los pasos a realizar los siguientes:
Entrorno. Se realizará uno o varios mapas, que será por donde se moverá el
móvil, y en el o los cuales se realizarán las adquisiciones de información, para
posteriormente entrenar la red neuronal que implementará el control.
Modelo del móvil. Se analizará la cinemática del robot para el cual se desea
realizar el controlador, para posteriormente implementar su modelo y poder
simular su comportamiento en distintos entornos. Además es necesario modelar
los sensores que se utilizarán para el guiado e integrarlos con el modelo
cinemático.
Adquisición de información para entrenamiento. Se realizará una simulación,
en la que el móvil se mueva por un entorno de la forma deseada. El guiado se
realizará de forma supervisada o semi-automática, es decir, es nuestra la
responsabilidad del guiado. Durante el tiempo que dure la simulación, se
registrará toda la información disponible, velocidades (lineal y angular), y
lectura de los sensores.
Diseño y entrenamiento del controlador (red neuronal). Partiendo de la
información que utilizaremos y las variables de salida necesarias, se diseñará la
red neuronal, la cual será entrenada con los datos registrados en una simulación
supervisada.
Prueba, validación y optimización del controlador. Con la red ya entrenada, se
realizarán simulaciones donde el guiado lo haga la red neuronal, y se probará en
distintos entornos, para comprobar que ha adquirido conocimiento suficiente, y
se tratará de optimizar el tamaño de la red para reducir en la medida de lo
posible, la carga computacional a la hora de implementarlo en una plataforma
real.
2
Objetivos
En esta práctica se pretende profundizar sobre los conocimientos necesarios para

el diseño e implementación de un Controlador Neuronal sobre sistemas robóticos.
Para ello se aplicarán los conocimientos obtenidos en las clases de teoría y se trabajará
en simulación con Matlab.
Se asentarán las bases para realizar modelos de sistemas reales partiendo de sus
ecuaciones y trabajar así en simulación, valorando las ventajas que esto aporta.
3
Modelo cinemático (propulsión diferencial)
En esta arquitectura, se sitúa un motor conectado a cada una de las ruedas tractoras, de
forma que variando la velocidad de cada uno de los motores se consigue que el motor
vaya recto, girando más o menos rápido. Por ejemplo, si la velocidad de las ruedas es
igual entonces el robot va recto. En cambio si se deja parada una rueda y se mueve la
otra el robot gira entorno al eje de giro situado en la rueda que está quieta.
Una de las grandes ventajas de esta cinemática es que el robot puede girar sobre sí
mismo, haciendo que las ruedas vayan a la misma velocidad pero en sentido contrario.
A continuación se deducen las ecuaciones del movimiento del robot.

Las siguientes ecuaciones indican cómo cambia la posición del robot, respecto de un
sistema de referencia fijo al entorno W, en un instante de tiempo.
4
En la siguiente figura, se muestra la cinemática diferencial de un vehículo, con el

objetivo de calcular el incremento de movimiento del mismo. Las ecuaciones que se
deducen son:
5
Diseño de uno o varios entornos
Para acondicionar una zona de trabajo, previamente hay que definir unas
características, como pueden ser las dimensiones, la resolución, el tipo de obstáculos,
ancho de pasillos, curvaturas, entre otras con el fin de que se asemeje lo más posible a
lo que será el entorno real.
Se adjunta entorno.bmp, que será el punto de partida para posteriores diseños:
Creación del modelo
El siguiente paso, es implementar las ecuaciones del modelo. Para ello se creará
un archivo , que será llamado MoverMovil.m, que tendrá la siguiente estructura:
6
Nota: el origen de coordenadas en una imagen es el punto superior izquierdo, por tanto,
el eje de coordenadas X, se corresponderá con el modelo visto, pero el eje de
coordenadas Y, será de sentido contrario, por tanto las sumas serán restas y viceversa.
7
Con el siguiente código fuente inicializamos las variables, gráficos y nombres de

ficheros Lo llamaremos
Inicialización
global h h1 px py t Ts Xmovil Ymovil Angle escala mapa pxsen pysen hs1 hs2 hd Figura
Vmovil Wmovil;
%Inicializacion del movil.
Xmovil=300;
Ymovil=200;
Angle=-pi/2;
Vmovil=25; % milimetros * segundo
Wmovil=-pi/5000;
Ts=0.001;
escala=4; % escala bmp -> 1 pixel = 4mm
Figura=figure('KeyPressFcn',@ControlTeclado); %Crea la figura y asocia una funcion si se
pulsa una tecla
axis equal;
mapa=imread('mapa3.bmp','bmp'); % Fichero que contiene el mapa
imshow(mapa,'truesize');
hold on;
set(gcf,'doublebuffer','on');
t=0:pi/8:2*pi;
h=line(t,t,'LineWidth',4);
px=[-55 -55 55 -55];
py=[-25 25 0 -25];
h1=line(px,py,'LineWidth',4);
pxsen(1,:)=[80*cos(pi/4) 800*cos(pi/4)];
pysen(1,:)=[-80*sin(pi/4) -800*sin(pi/4)];
pxsen(2,:)=[80*cos(-pi/4) 800*cos(-pi/4)];
pysen(2,:)=[-80*sin(-pi/4) -800*sin(-pi/4)];
hs1=line(pxsen(1)/escala,pysen(1)/escala,'LineWidth',2);
hs2=line(pxsen(2)/escala,pysen(2)/escala,'LineWidth',2);
hd(1)=line([1 1],[1 1],'Marker','+','Color','r');
hd(2)=line([1 1],[1 1],'Marker','+','Color','r');
tex = text(300,260,'texto');
set(tex,'BackgroundColor',[1 1 .6])
tex1 = text(300,280,'texto1');
set(tex1,'BackgroundColor',[1 1 .6])
DibujaMovil
Este código fuente, reubica las entidades gráficas en sus lugares correspondientes.
function movil=DibujaMovil(X,Y,Angle)
global h h1 px py t escala;
set(h,'XData',(X+80*cos(t))/escala);
set(h,'YData',(Y+80*sin(t))/escala);
%Rotacion
Pxr=px(1:4)*cos(-1*Angle)-py(1:4)*sin(-1*Angle);
Pyr=px(1:4)*sin(-1*Angle)+py(1:4)*cos(-1*Angle);
set(h1,'XData',(X+Pxr)/escala);
set(h1,'YData',(Y+Pyr)/escala);
movil=0;
8
ControlTeclado
Este archivo, es llamado cuando estando el foco centrado en la imagen de simulación se

pulsa alguna tecla.
function ControlTeclado(S1,S2)
global Vmovil Wmovil Figura;
IncV=50;
IncW=pi*0.05;
switch double(get(Figura,'CurrentCharacter'))
case 28
Wmovil=Wmovil+IncW;
case 29
Wmovil=Wmovil-IncW;
case 30
Vmovil=Vmovil+IncV;
case 31
Vmovil=Vmovil-IncV;
End
Sensores
Este archivo, implementa el modelo de los sensores.

function sense=Sensores
global Xmovil Ymovil Angle escala mapa pxsen pysen hs1 hs2 hd;
%sensores a +45º y -45º
Tethasensor=[pi/4 -pi/4];
%trazado alcance sensores
Pxsenr=pxsen(1:2,:)*cos(Angle)+pysen(1:2,:)*sin(Angle);
Pysenr=-pxsen(1:2,:)*sin(Angle)+pysen(1:2,:)*cos(Angle);
set(hs1,'XData',(Xmovil+Pxsenr(1,:))/escala);
set(hs1,'YData',(Ymovil+Pysenr(1,:))/escala);
set(hs2,'XData',(Xmovil+Pxsenr(2,:))/escala);
set(hs2,'YData',(Ymovil+Pysenr(2,:))/escala);
%Busqueda obstaculo
sense=[0 0];
for i=80:800 %80/escala=20 hasta 800/escala=200
pxsenb=[i*cos(pi/4) i*cos(-pi/4)];
pysenb=[-i*sin(pi/4) -i*sin(-pi/4)];
%Rotacion
Pxsenbr=pxsenb*cos(Angle)+pysenb*sin(Angle);
Pysenbr=-pxsenb*sin(Angle)+pysenb*cos(Angle);
%Traslacion
pxsenb=(Xmovil+Pxsenbr)/escala;
pysenb=(Ymovil+Pysenbr)/escala;
for ii=1:2
if sense(ii)==0
if mapa(round(pysenb(ii)),round(pxsenb(ii)))==0
sense(ii)=i;
set (hd(ii),'XData',pxsenb(ii)*[1 1]);
set (hd(ii),'YData',pysenb(ii)*[1 1]);
end
end
end
if sense(1)>0 & sense(2)>0
return
end
end
for ii=1:2
if sense(ii)==0
sense(ii)=800;
end
end
9
Principal
Este archivo, es el bloque principal, se encarga de ir llamando a las
correspondientes funciones, con el fin de realizar el guiado supervisado y registrar el
valor de las variables.
close all;
clear all;
Vmovil Wmovil;
Inicializacion;
for i=0:200000
MueveMovil(Vmovil, Wmovil);
if mod(i,200)==0 %solo se ejecuta una vez cada 200 iteraciones (5 veces por seg.
para TS=1ms)
sense=Sensores; %lectura sensores
if i>0
Rsense=[Rsense; sense];
RVmovil=[RVmovil; Vmovil];
RWmovil=[RWmovil; Wmovil];
else
Rsense=[sense];
RVmovil=[Vmovil];
RWmovil=[Wmovil];
end
DibujaMovil(Xmovil, Ymovil, Angle); %Actualiza animacion
drawnow;
set(tex,'String',num2str(i)); %visualiza en pantalla iteracion y sensores
set(tex1,'String',num2str(sense));
%Como ayuda al guiado se puede llamar a SemiControl
%if mod(i,400)==0
%Wmovil=SemiControl(sense); %se ejecuta cada 1000 iteraciones (1 vez/seg
para Ts=1ms)
%end
end
end
save 'registro.mat' Rsense RVmovil RWmovil;
Principal_2
Este archivo, es el bloque principal, que se encargará de ir llamando a las

correspondientes funciones, con el fin de implementar el guiado con la red neuronal.
close all;
clear all;
Vmovil Wmovil;
Inicializacion;
load 'Entrenamiento.mat'
for i=0:200000
MueveMovil(Vmovil, Wmovil);
if mod(i,200)==0 %solo se ejecuta una vez cada 200 iteraciones (5 veces por seg.
para TS=1ms)
sense=Sensores; %lectura sensores
Salida=RedNeuronal(sense(1),sense(2));
Vmovil=Salida(1);
Wmovil=Salida(2);
DibujaMovil(Xmovil, Ymovil, Angle); %Actualiza animacion
drawnow;
set(tex,'String',num2str(i)); %visualiza en pantalla iteracion y sensores
set(tex1,'String',num2str(sense));
end
end
10
Superficies
Este archivo, muestra la superficie de la velocidad lineal y de la velocidad angular en

función de los sensores, tanto para los datos registrados en el proceso de guiado
supervisado, como de la salida de la red neuronal una vez entrenada.
load 'Entrenamiento.mat'
load 'Registro.mat'
S1=Rsense(:,1);
S2=Rsense(:,2);
Vm=RVmovil;
Wm=RWmovil;
inc=60;
ii=0;
for i=80:inc:800
ii=ii+1;
jj=0;
for j=80:inc:800
jj=jj+1;
superfV(ii,jj)=mean(Vm(find(S1>=i & S1<i+inc & S2>=j & S2<j+inc)));
superfW(ii,jj)=mean(Wm(find(S1>=i & S1<i+inc & S2>=j & S2<j+inc)));
superfneuronal(ii,jj,:)=RedNeuronal(i+inc/2,j+inc/2);
end
end
figure(2);
subplot(2,2,1);meshc(1:size(superfV,1),1:size(superfV,1),superfV);
title 'Velocidad lineal (guiado supervisado)';
subplot(2,2,2);meshc(1:size(superfneuronal,1),1:size(superfneuronal,1),superfneuronal(:,
:,1));
title 'Velocidad lineal (guiado con red neuronal)';
subplot(2,2,3);meshc(1:size(superfW,1),1:size(superfW,1),superfW);
title 'Velocidad angular (guiado supervisado)';
subplot(2,2,4);meshc(1:size(superfneuronal,2),1:size(superfneuronal,2),superfneuronal(:,
:,2));
title 'Velocidad angular (guiado con red neuronal
Pruebas del modelo.
Para probar que el modelo funciona correctamente, se integrará en el

programa general, y al ejecutarlo, mediante las flechas del teclado se podrá modificar
tanto la velocidad lineal (arriba, abajo), como la angular (izquierda, derecha). Con esto,
se realizará un guiado para ver que la trayectoria que sigue el móvil tiene coherencia.
Hay que comprobar que en la misma carpeta, se encuentran los ficheros:
Entorno.bmp, que es la imagen que emula el entorno.

Inicialización.m, que es el script que inicializa variables y declara las
componentes gráficas utilizadas para la simulación.
DibujaMovil.m, que es el script encargado de dibujar el móvil en sus nuevas
coordenadas.
ControlTeclado.m, que es el script que se llama al pulsar una tecla con el foco
en la imagen de simulación, y modifica las variables de velocidad.
MueveMovil.m, que es el script visto anteriormente, que implementa el modelo
del movil.
11
Sensores.m, que es el script que implementa el modelo de los sensores.

Principal.m, que es el script principal, el cual irá llamando a las distintas
funciones.
Adquisición de datos para entrenamiento

Ahora realizamos un guiado del móvil de forma manual, o semiautomática, para
registrar periódicamente los valores de las velocidades (lineal y angular), y la lectura de
los sensores.
Tras la ejecución y guiado se habrá creado un fichero con el registro de las variables
registro.mat, el cual será el que se utilizará posteriormente para realizar el
entrenamiento de la red neuronal.
Diseño y entrenamiento del controlador (red neuronal)

Lo primero que se debemos plantear, es el número de variables de entrada y de
salida que se utilizaremos, siendo dos entradas (sensores), y dos salidas
(velocidad lineal y velocidad angular).
donde las salidas sean función única y exclusivamente del valor de las entradas en ese
instante.
Se definió que el tipo de red a utilizar, será una Red de Base Radial (RBF).
Para el diseño y entrenamiento se utilizará la función newrb, a la cual, se le
darán los datos registrados en la adquisición durante el guiado supervisado.
close all;
clear all;
global IW B1 B2 W;
load 'Registro.mat'
P=Rsense';
T=[RVmovil RWmovil]';
%Entrenamiento
eg =100; % error cuadratico medio deseado
sc = 200; % varianza de las funciones RBF (defecto 1.0)
MN=30; %maximo numero de neuronas
net=newrb(P,T,eg,sc,MN,1);
IW= net.iw{1};
B1=net.b{1};
B2=net.b{2};
W=net.lw{2,1};
save 'Entrenamiento.mat' IW B1 B2 W;
Este código es el script llamado Entrena, y mostrará la evolución del error

según se añaden neuronas. Se puede observar como las variables se cargan del fichero
Registro.mat, que fue creado en el proceso previo, y el resultado del entrenamiento, es
decir, la configuración de la red y el ajuste de pesos y centroides, se guardará en el
fichero Entrenamiento.mat.
Una vez definida y configurada la red, se realizará la función que implemente la
red neuronal, la cual se llamará RedNeuronal., y tendrá el siguiente formato:
12
function Y=RedNeuronal(S1,S2)
global IW W B1 B2;
%%%%% ECUACIONES QUE IMPLEMENTAN LA RED DE BASE RADIAL
%%%%% DONDE IW, W, B1, B2, SON LOS AJUSTES
%%%%% S1, S2, SON LAS ENTRADAS
%%%%% LA SALIDA SE DEVOLVERA EN Y
Y=W*a1'+B2;
Prueba, validación y optimización del controlador

ya disponemos de un script que implementara la red ya entrenada, para saber si el
entrenamiento es suficientemente fiel, podemos fijarnos en el error cuadrático
medio obtenido, lo cual se utiliza únicamente como referencia relativa, es decir, si es
mejor entrenamiento el de una red que el de otra, lo cual siempre debe realizarse con
los mismos vectores de entrenamiento. Este valor dependerá de la cantidad de datos que
se utilicen en este proceso.
Un mejor método para comprobar si la red neuronal entrenada responde de
forma similar al guiado supervisado, es comparar las superficies de salida en función de
las entradas.
Para ello utilizaremos el archivo Superficies.
Como resultado, se muestran las siguientes figuras:
13
Observamos que la superficie del guiado supervisado es incompleta, debido a que en

durante el proceso de captura de información, no se han dado todos los posibles casos.
Sin embargo, la red neuronal sí que tiene todos los puntos definidos.
Resulta muy útil pasar por la comprobación de las superficies, principalmente,

para determinar el valor de la varianza de las funciones gaussianas.
Para probar la red guiando el móvil, se utilizaremos una variante del programa
principal utilizado en el guiado con supervisión, que será Principal_2.m.
Una vez probado en el entorno, en el que ha sido entrenado, se puede poner a
prueba en otros entornos, en los cuales el funcionamiento debe ser similar.
Por último, optimizamos el diseño de la red para utilizar el menor número
de neuronas posible. Para ello, utilizamos como ayuda la gráfica de la función
newbr, y en el momento en el que no se detecte una reducción importante en el error,
puede ser el número de neuronas a utilizar, ya que todas las que se agreguen desde ese
punto, no tendrán mucha influencia en el resultado.
14
Anexo No I.
REDES DE BASE RADIAL (RBF):

Estas redes, requieren más neuronas que las redes feed-foward, pero generalmente se
diseñan en una fracción de tiempo menor que las redes backpropagation. Se obtenien
excelentes resultados si se entrenan con los vectores apropiados.
Tipo de Neurona
La función radbas implementa la función de transferencia de una neurona RBF.
El argumento de la función radbas no es el mismo que en las neuronas de otros tipos de
redes, sino que en este tipo de neuronas, el argumento es la distancia entre el vector de
pesos w y el vector de entrada p, multiplicada por la bia b.
En el gráfico de la izquierda, se ve que la función de base radial tiene su máximo
en 0. En el de la derecha se puede observar la función de base radial con w y b. Si la
distancia entre w y p decrece, la salida de la neurona crece. Así pues la neurona de base
radial puede actuar como un detector de vectores, ya que si w=p la salida de la neurona
es 1, y en caso contrario, nunca es 1.
La bias b muestra la sensibilidad de la neurona para ser ajustada, por ejemplo, si
una neurona tiene bia con valor de 0.1, su salida será 0.5 para un vector de entrada p
cuya distancia a w sea 8.326 (0.8326/b).
Arquitectura de Redes RBF
Una red de base radial consta de dos capas; una oculta de neuronas radbas con
S1 neuronas, y una de salida purelin, con S2 neuronas.
Diseño de la Red de Base Radial

La función newrb crea la red de forma iterativa, mostrando la evolución del
error cuadrático medio, según se van añadiendo neuronas.
Net = newrb(P, T, Goal, Spread, MN, DF);
Esta función requiere como parámetros el vector de entradas y el vector de salidas que
debe corresponder a dichas entradas, el error deseado como objetivo (Goal),
la varianza de la función Gaussiana (Spread), número máximo de neuronas a añadir
(MN), y el periodo de refresco de la gráfica que muestra la evolución del error según se
añaden neuronas (DF).
Al utilizar esta función para el diseño y entrenamiento de la red, es fácil
determinar un correcto número de neuronas.
Net, es lo que devuelve la función, que es una estructura que contiene los ajustes
de la red para los datos de entrenamiento dados.
Nota: Esta función realiza el ajuste de los pesos y de los centroides de las
gaussianas, pero la varianza de todas ellas es la misma, que además debe
introducirla el usuario.
15
Conclusiones
Fue interesante realizar este proyecto debido a que gracias a el adquirimos destreza en
cuanto al manejo de simulación de redes Neuronales.
Para la realización de proyectoi fue necesario crear una libreria en Matlab para conseguir
el conjunto de datos de entrenamiento. Esta tarea resulto ser una de las mas complejas e
importantes del trabajo, ya que los ejemplos de entrenamiento son claves para el correcto
aprendizaje de la red.
BIBLIOGRAFIA
Brooks,R. “A Robust Layered Control System for a Mobile Robot”, IEEE Journal
or Robotics and Automation, Vol. RA-2,No1,pp 14-23.
Chronis,G. Skubic, M.;”Training a Neural Network for Navigation
Behaviors”. Dept. or Computer Engineering and Computer
Science. University of Missouri-Columbia.
Marcos Provecho, M.C. “Autoguiado de Robots Móviles mediante
Redes Neuronales”. PFC . Escuela de Ingenierias Industrial e
Informatica. Universidad de Leon.
MathWoks “Neural network Toolbox”.
Mitchell, R.J. , Keating,D.A.; “Neural Network
Control of Simple Mobile Robot”. Department of
http://fcqi.tij.uabc.mx/docentes/esqueda/guide.pdf
16

Proyecto Final Grupo No. 0 6 PDF

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Proyecto Final Grupo No. 0 6 PDF

Caricato da

Copyright:

Formati disponibili

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA Fecha:

ESCUELA DE CIENCIAS BASICAS E INGENIERIAS Junio de 2010

SISTEMAS AVANZADOS DE CONTROL

GUIADO DE ROBOT CON UNA RED NEURONAL

JAINSON POLO DE LA HOZ

VALLEDUPAR - COLOMBIA JUNIO DE 2010

En el Trabajo Final , se aborda un problema completo de guiado de un móvil, buscando

En esta práctica se pretende profundizar sobre los conocimientos necesarios para

Modelo cinemático (propulsión diferencial)

A continuación se deducen las ecuaciones del movimiento del robot.

En la siguiente figura, se muestra la cinemática diferencial de un vehículo, con el

Diseño de uno o varios entornos

Creación del modelo

Con el siguiente código fuente inicializamos las variables, gráficos y nombres de

Este archivo, es llamado cuando estando el foco centrado en la imagen de simulación se

Este archivo, implementa el modelo de los sensores.

Este archivo, es el bloque principal, que se encargará de ir llamando a las

Este archivo, muestra la superficie de la velocidad lineal y de la velocidad angular en

Pruebas del modelo.

Para probar que el modelo funciona correctamente, se integrará en el

Entorno.bmp, que es la imagen que emula el entorno.

Sensores.m, que es el script que implementa el modelo de los sensores.

Adquisición de datos para entrenamiento

Diseño y entrenamiento del controlador (red neuronal)

Este código es el script llamado Entrena, y mostrará la evolución del error

Prueba, validación y optimización del controlador

Observamos que la superficie del guiado supervisado es incompleta, debido a que en

Resulta muy útil pasar por la comprobación de las superficies, principalmente,

REDES DE BASE RADIAL (RBF):

Diseño de la Red de Base Radial

Potrebbero piacerti anche