auto modelamiento de un brazo robÓtico informe final 2014. 2. 26. · brazo cilíndrico: los ejes...
TRANSCRIPT
AUTO-MODELAMIENTO DE UN BRAZO
ROBÓTICO: INFORME FINAL
Profesores: Augusto Lucero A.
Jorge Romo L.
Auxiliar: Adio Stefoni E.
Alumnos: Ignacio Cano D.
Andrés Peñaloza G.
Gaspar Pizarro V.
Ian Yon Y.
Fecha: 29 de julio de 2013
CONTENIDO 1 Introducción y Resumen ............................................................................................................................................. 5
1.1 Manipulación robótica ....................................................................................................................................... 5
2 Contextualización .......................................................................................................................................................... 7
2.1 Robótica y modelos ............................................................................................................................................. 7
2.2 Procesos de Decisión de Markov (PDM o MDP) ...................................................................................... 7
2.3 Aprendizaje Reforzado ...................................................................................................................................... 9
2.4 TEXPLORE ............................................................................................................................................................. 11
2.4.1 Aprendizaje del modelo ......................................................................................................................... 11
2.4.2 Exploración ................................................................................................................................................. 11
2.4.3 Planificación ................................................................................................................................................ 12
2.5 ROS ........................................................................................................................................................................... 13
2.6 Trabajo Actual ..................................................................................................................................................... 14
3 Implementación ............................................................................................................................................................ 15
3.1 Sub-Grupo de Rediseño Mecánico ............................................................................................................... 15
3.2 Sub-Grupo de investigación ........................................................................................................................... 17
3.2.1 rl_common ................................................................................................................................................... 17
3.2.2 rl_msgs .......................................................................................................................................................... 20
3.2.3 rl_agent ......................................................................................................................................................... 22
3.2.4 rl_env ............................................................................................................................................................. 23
3.2.5 rl_experiment ............................................................................................................................................. 23
3.2.6 Pruebas preliminares .............................................................................................................................. 23
3.2.7 Adaptación algoritmo ............................................................................................................................. 24
4 Resultados ....................................................................................................................................................................... 25
4.1 Investigación ........................................................................................................................................................ 25
4.2 Modelo Geométrico ........................................................................................................................................... 25
4.3 Construcción ........................................................................................................................................................ 27
4.4 Pruebas del sistema .......................................................................................................................................... 31
5 Discusión de resultados ............................................................................................................................................ 32
5.1 Modelo Geométrico ........................................................................................................................................... 32
5.2 Construcción ........................................................................................................................................................ 32
6 Evaluación económica................................................................................................................................................ 34
7 Conclusiones .................................................................................................................................................................. 35
8 Bibliografía ..................................................................................................................................................................... 36
9 Anexos .............................................................................................................................................................................. 37
9.1 Planificación del Proyecto ........................................................................................................................... 37
9.1.1 Carta Gantt ................................................................................................................................................... 37
9.1.2 Curva S ......................................................................................................................................................... 38
9.2 Presentación de diapositivas sobre TExplore: ....................................................................................... 39
9.3 Presentación sobre UCT (Upper Confidence Bounds applied to Trees)...................................... 41
9.4 Presentación sobre árboles y bosques aleatorios................................................................................. 44
ÍNDICE DE ILUSTRACIONES
Ilustración 1 Brazos robóticos de izquierda a derecha: Cartesiano, SCARA, paralelo, articulado ......... 5
Ilustración 2 Efectores de izquierda a derecha: herramienta, sujeción, pinza, antropomórfico ............ 6
Ilustración 3 Brazo de robot Turtlebot........................................................................................................................... 6
Ilustración 4 Ejemplo de PDM con 3 estados y 2 acciones ..................................................................................... 8
Ilustración 5 Diagrama de bloques Aprendizaje Reforzado en tiempo real ................................................... 9
Ilustración 6 Aprendizaje del modelo ........................................................................................................................... 12
Ilustración 7 Robot Turtlebot ........................................................................................................................................... 13
Ilustración 8: Diagrama de funcionamiento Ros ...................................................................................................... 14
Ilustración 9: Vistas del turtlebot disponible ............................................................................................................. 14
Ilustración 10: Diagrama de flujo de rediseño mecánico ...................................................................................... 16
Ilustración 11: Mensajes de comunicación entre agente y entorno ................................................................. 20
Ilustración 12: Modelo de robot para rediseño mecánico .................................................................................... 25
Ilustración 13: Vista de cámara inferior ...................................................................................................................... 27
Ilustración 14: Robot Turtlebot modificado ............................................................................................................... 28
Ilustración 15: Comparación entre robot original y robot modificado ........................................................... 29
Ilustración 16: Servo utilizado en el brazo robótico, modelo AX-12A. ............................................................ 31
Ilustración 17: Alcance del brazo en el suelo ............................................................................................................. 32
Ilustración 18: Curva S del proyecto ............................................................................................................................. 38
ÍNDICE DE TABLAS Tabla 1 Algoritmos para resolver PDM ........................................................................................................................ 10
Tabla 2: Especificaciones del servo AX-12a, utilizado en el brazo robótico. ................................................ 30
Tabla 3: Costos de piezas para rediseño mecánico ................................................................................................. 34
Tabla 4: Carta Gantt del proyecto ................................................................................................................................... 37
1 INTRODUCCIÓN Y RESUMEN
1.1 MANIPULACIÓN ROBÓTICA Un aspecto interesante del estudio de la robótica es la manipulación de objetos en el entorno. Este
problema considera un sinnúmero de variables y enfoques que dependen de la aplicación específica
que sea de interés, donde en el ámbito industrial se tienen aplicaciones como movimiento de
objetos de un lugar a otro, operaciones de ensamblado, manipulación de máquinas y herramientas,
soldadura por punto, fundición a presión, pintado en spray, etc.
Un manipulador se compone de un efector final y un brazo que mueve este efector a una posición
determinada.
Los brazos robóticos pueden ser clasificados en (Ver Ilustración 1):
Brazo cartesiano: Se compone generalmente de tres articulaciones, cuyos ejes son
coincidentes con los ejes cartesianos.
Brazo cilíndrico: Los ejes de este brazo forman un sistema de coordenadas cilíndricas.
Brazo esférico: Los ejes del brazo forman un sistema polar de coordenadas.
Brazo SCARA: Es un robot que tiene dos articulaciones rotatorias paralelas para
proporcionar elasticidad en un plano.
Brazo articulado: Es un robot cuyo brazo tiene como mínimo tres articulaciones rotatorias.
Brazo/Robot paralelo: Es un robot cuyos brazos tienen articulaciones prismáticas o
rotatorias concurrentes. 1
Ilustración 1 Brazos robóticos de izquierda a derecha: Cartesiano, SCARA, paralelo, articulado
Dentro de los manipuladores más usados están los del tipo (Ver Ilustración 2):
Herramienta: usados para aplicaciones industriales (Soldadura de arco).
Sujeción: usan ventosas, electroimanes, etc. Y se han usado principalmente en
investigación.
Pinza: 2 o más pinzas que sirven para agarrar objetos que quepan dentro de las pinzas
Antropomórficos: Tiene como objetivo emular una mano humana, con dedos
independientes y pulgar.
Ilustración 2 Efectores de izquierda a derecha: herramienta, sujeción, pinza, antropomórfico
De las múltiples variaciones de arquitectura de brazos y efectores robóticos se ve que es difícil
tener una configuración global para todos los robots, por lo que es necesario estar configurando
independientemente cada uno. Esta configuración debe ser hecha por profesionales altamente
capacitados, lo que incrementa el costo del desarrollo y mantención de manipuladores robóticos.
En el presente proyecto se busca desarrollar un sistema de modelamiento de manipuladores
robóticos que facilite la configuración de los mismos, partiendo de un manipulador articulado
integrado en un robot Turtlebot equipado con un efector de pinzas (Ver Ilustración 3), de forma que
sea extensible para robots de propósito general en un futuro. El informe de avance muestra lo
logrado hasta la fecha en el proyecto, en el contexto del ramo EL5002 Introducción al Taller de
Diseño de la carrera de Ingeniería Civil Eléctrica. Se muestra una contextualización al tema,
mostrando el problema que se quiere tratar y su origen, luego se muestra una revisión bibliográfica
de los temas relacionados a este y finalmente se muestra la planificación del proyecto en términos
de tiempo, usando una carta Gantt y una curva S. En los anexos se adjuntan presentaciones
realizadas sobre los algoritmos a tratar.
Ilustración 3 Brazo de robot Turtlebot
2 CONTEXTUALIZACIÓN
2.1 ROBÓTICA Y MODELOS Los modelos que tiene un robot son fundamentales para que este pueda comprender su entorno y
tomar decisiones dentro de él. Un tipo de modelos, conocidos como modelos del proceso, dicen
relación con los efectos que tienen las acciones del robot en la evolución del estado de su
ambiente. Otro tipo de modelos, conocidos como modelos observacionales, se relacionan con las
observaciones que el robot espera recibir a través de sus sensores, dado que el ambiente se
encuentra en un determinado estado. Convencionalmente, ambos tipos de modelos son
construidos teóricamente a partir de consideraciones cinemáticas, dinámicas, ópticas, etc. Este tipo
de procedimiento para la construcción de modelos requiere del trabajo de una persona altamente
calificada y descansa en muchos supuestos que usualmente no son ciertos. Más aún, típicamente,
para realizar este tipo de procedimiento, es necesario contar con el valor de varias variables físicas
involucradas, como dimensiones físicas del robot, desplazamientos en sus articulaciones,
especificaciones de sus motores, etc., las cuales siempre tienen un cierto grado de error en su
medición. Este error se puede propagar y magnificar en los modelos, produciendo a veces errores
garrafales.
Existe, sin embargo, la posibilidad de reemplazar (o complementar) los modelos teóricos
previamente mencionados por otros construidos en forma estadística a partir de datos reales. Este
tipo de procedimiento disminuye la necesidad de contar con personas calificadas para la
construcción de los modelos, corrige naturalmente los errores existentes en la medición de las
variables físicas y, más aún, permite al robot cambiar sus modelos cuando ellas cambien, incluso en
operación.
Este tipo de modelamiento usualmente descansa en técnicas de aprendizaje supervisado como
Redes Neuronales, Procesos Gaussianos o un conjunto de metodologías como Procesos de Decisión
de Markov, Programación Dinámica y Aprendizaje Reforzado.
2.2 PROCESOS DE DECISIÓN DE MARKOV (PDM O MDP) Los procesos de decisión de Markov [1] son una estructura matemática para modelar la toma de
decisiones en situaciones donde las recompensas son en parte aleatorias y en parte bajo el control
de un agente.
Los PDM tienen el siguiente funcionamiento:
En cada momento (caso discreto) el agente se encuentra en un estado S.
El agente elige una acción a de las acciones disponibles para el estado S.
Al siguiente momento temporal el proceso responde moviendo al agente a un estado S’ y
dándole una recompensa .
La probabilidad de llegar a un estado S’ partiendo de un estado S al realizarse una acción a
se modela como una probabilidad de transición .
De esta forma el PDM queda formulado como una 4-tupla:
Donde
S es un conjunto finito de estados.
A es un conjunto finito de acciones.
es la probabilidad de que la acción a en el
estado s en el momento t lleve al estado s’ en el momento t+1.
es la recompensa inmediata recibida después de la transición al estado s’
desde el estado s.
Ilustración 4 Ejemplo de PDM con 3 estados y 2 acciones
Para el caso de los PDM de tiempo continuo, la diferencia es que el agente puede seleccionar la
acción en el momento que quiera.
La problemática en los PDM es encontrar la política óptima que maximice las recompensas en el
tiempo, donde generalmente las recompensas inmediatas importan más que las lejanas en el
pasado (factor de descuento). Cuando las probabilidades de transición o las recompensas son
desconocidas, se trata de un problema de aprendizaje reforzado [2].
2.3 APRENDIZAJE REFORZADO Lo que distingue al aprendizaje reforzado de las técnicas clásicas es que este último no necesita
conocimiento sobre el PDM y tiene como objetivo principal resolver vastos PDM de manera
aproximada, donde los métodos exactos no encuentran soluciones (o no las encuentran en tiempo
acotado o útil).
La principal problemática del aprendizaje reforzado es el dilema de exploración/explotación, en la
que se necesita encontrar un equilibrio entre explotar la política de la que se dispone de forma de
maximizar las recompensas, y explorar nuevos estados para encontrar mejores recompensas que
explotar. Dado que esto se hace simultáneamente, al explorar nuevos estados no se pueden
explotar los conocidos, con lo que disminuye la recompensa obtenida y se infiere que explorar
demasiado no es deseable. Por otro lado si solo se explota la política de la que se dispone se tiene el
problema de las condiciones iniciales, donde se tendría que tener cierta cantidad de información (lo
que no siempre es posible) inicialmente de forma de explotarla, y si se tiene esta información se
podría tener que hay grandes recompensas en estados no explorados y se están desperdiciando
debido a demasiada explotación.
Dentro del ámbito del Aprendizaje Reforzado resulta de particular interés el aprendizaje reforzado
en tiempo real, puesto que permite fundir el periodo de entrenamiento con el de operación y
mejorar continuamente el periodo de operación. Podemos resumir el ciclo de un algoritmo de
aprendizaje reforzado en tiempo real en la Ilustración 5.
Los algoritmos de aprendizaje reforzado resuelven el dilema Exploración/Explotación, y tienen
diferentes parámetros que optimizan el desempeño del algoritmo en determinadas situaciones.
Algunos de los algoritmos más populares se resumen en la Tabla 1 [3]
Entorno
Actualizar
modelo con
experiencias
Planificar sobre el
modelo
actualizado
Retornar
acción elegida
por la política
Agente
Estado s Recompensa r Acción a
Ilustración 5 Diagrama de bloques Aprendizaje Reforzado en tiempo real
Algoritmo Eficiente en ejemplos Tiempo real Tiempo continuo Retardos
R-MAX Si No No No
Q-LEARNING No Si No No
With F. A. No Si Si No
SARSA No Si No No
PILCO Si No Si No
NAC Si No Si No
BOSS Si No No No
Bayesian DP Si No No No
MBBE Si No No No
SPITI Si No No No
MBS Si No No Si
U-TREE Si No No Si
DYNA No Si No No
DYNA-2 No Si Si No
KWIK-LR Si No No No
FITTED R-MAX Si No Si No
DRE Si No Si No
TEXPLORE Si Si Si Si
Tabla 1 Algoritmos para resolver PDM
De estos algoritmos y su tabla resumen se extraen varias características que necesita el dominio de
cada algoritmo. Para el caso particular de interés se necesita que sea eficiente en ejemplos, de
tiempo real y de tiempo continuo, y aquel destaca por su aplicabilidad en gran número de
escenarios y buen desempeño respecto a sus competidores es TExplore [4] [5] [3] que recoge
elementos de varios algoritmos populares como UCT [6], Decision Trees [7] y los modifica para
conseguir un algoritmo de notable desempeño comparado con varios algoritmos exitosos.
2.4 TEXPLORE TEXPLORE es un algoritmo basado en modelos que aprende varios modelos posibles del proceso y
los promedia para obtener un modelo que representa la incerteza en el dominio. Es capaz de
explorar áreas donde tiene un menor grado de conocimiento agregando recompensas a la
exploración y el agente re-plantea su política en cada instante de tiempo encontrando la mejor
acción de acuerdo al modelo y las recompensas.
2.4.1 APRENDIZAJE DEL MODELO El algoritmo aprende el efecto de las transiciones (diferencia) en vez de un estado absoluto. Esto le
permite generalizar mejor dado que en muchos casos las acciones tienen efectos similares en
diferentes estados. Para aproximar la probabilidad de transición, realiza una predicción separada
por cada característica del estado (incluyendo recompensa), de forma que la probabilidad de
transición se calcula en la Ecuación 1. Al hacer esto, sin embargo, se está asumiendo que cada
característica del estado puede ser predicha por separado, lo que no es siempre necesariamente
cierto, por lo que debe ser considerado al momento de implementarlo.
Ecuación 1: Ecuación de probabilidad de transición
∏
Para cada característica se construye un Bosque aleatorio, formado por muchos árboles de decisión
que se entrenan en un subconjunto de las experiencias; o sea que cuando el agente elige una
acción, actualiza el modelo con una probabilidad dada, lo que aumenta la capacidad de
generalización del modelo. Se puede ver un diagrama en la Ilustración 6.
Los árboles se construyen recursivamente usando el algoritmo C4.5, dividiendo el nodo con la
mayor razón de ganancia de información, a menos que esta ganancia no supere cierto valor umbral,
en cuyo caso se convierte en un nodo hoja.
2.4.2 EXPLORACIÓN Para la exploración se comprueba que el algoritmo funciona mejor cuando se actúa
avariciosamente respecto del promedio de los modelos. Esto se hace modificando la función de
recompensa como se ve en la Ecuación 2. Al cambiar el parámetro b se puede conseguir un
comportamiento avaricioso para , un comportamiento con tendencia a la exploración para
, y uno que evita los estados inciertos para .
Ecuación 2: Función de recompensa modificada
2.4.3 PLANIFICACIÓN El algoritmo usa una versión modificada de UCT para planificar sus acciones. Para esto construyen
un árbol en función de los nodos (pares estado/acción) que va visitando, y almacena el valor
estimado del nodo (recompensa), y número de veces que ha sido visitado. Se debe seleccionar nodo
que maximiza:
Ecuación 3: Selección de nodos
√
Donde
• : valor estimado del nodo
• : parámetro ajustable de bias.
Ilustración 6 Aprendizaje del modelo
Encontrar el efecto de la transición
Predecir característica 1 Recompensa
Separar cada característica a predecir
Agregar experiencia
con probabilidad w
… Árbol C4.5
Árbol C4.5
… m arboles
Promedio
Bosque aleatorio de m árboles
Combinar con Ecuación 1
Bosque n Bosque 1
Bosque n+1
Característica n
• : número de veces que el padre ha sido visitado
• : número de veces que ha sido visitado el nodo
Este algoritmo tiene las ventajas de que puede ser detenido en cualquier momento entregando la
mejor política y que al buscar en el árbol explora más las zonas donde obtiene una mejor
recompensa, así como mantiene los incentivos para la exploración de zonas desconocidas.
2.5 ROS Ros (Robot Operative System) es un sistema de código libre para el desarrollo de aplicaciones para
diversos tipos de robots. Sus principales virtudes son que favorece la integración de nuevos robots y
la reusabilidad de las aplicaciones ya creadas para un robot especifico. Algunos de los robots que
están disponibles actualmente con Ros son: Willow Garage Turtlebot (Ver Ilustración 7), Willow
Garage PR2, Lego NXT, Aldebaran Nao, IRobot Roomba, Kobuki, entre otros.
Ilustración 7 Robot Turtlebot
Podemos resumir a groso modo el funcionamiento de Ros como una arquitectura cliente servidor
como la mostrada en la Ilustración 8, donde los Nodos son las aplicaciones de Ros y los tópicos son
un canal de comunicación. Los nodos se suscriben a tópicos publicados por otros nodos, y de esta
forma los Nodos que están publicando en el tópico le envían la información relevante a los nodos
suscritos. Muchos nodos pueden suscribirse a un tópico y puede hacerse en Red, lo que facilita la
interacción entre robots y de forma lejana. La información en enviada en estructuras de datos
llamadas Mensajes, los que pueden definirse para la aplicación específica. Un conjunto de nodos se
llama Paquete, y un conjunto de paquetes con una finalidad es un Stack.
2.6 TRABAJO ACTUAL Se pretende con este proyecto el auto-modelamiento de un brazo robótico instalado en un robot
Turtlebot [8], que se muestra en la Ilustración 9 de forma que este aprenda los parámetros del
mismo y mejore su desempeño al realizar tareas. Para esto se analizarán y modificaran técnicas de
aprendizaje reforzado con el fin de adaptarlas al dominio del problema. El proyecto se realizará con
el respaldo del Grupo de Robótica del DCC, que han facilitado el robot, las dependencias y entregan
apoyo académico sobre la plataforma y el robot en cuestión.
Ilustración 9: Vistas del turtlebot disponible
Ilustración 8: Diagrama de funcionamiento Ros
Nodo Nodo
Invocación de servicio
Tópico
Publicación Suscripción
3 IMPLEMENTACIÓN
Para la realización del proyecto se vieron dos temas que se deben realizar para el avance global de
éste. Por ello, el grupo de trabajo se dividió en dos subgrupos. Andrés Peñaloza y Gaspar Pizarro se
encargarán del rediseño mecánico del robot, mientras que Ignacio Cano e Ian Yon se encargarán del
análisis bibliográfico de los métodos de aprendizaje reforzado a usar en este proyecto.
3.1 SUB-GRUPO DE REDISEÑO MECÁNICO
El grupo de rediseño mecánico, formado por Andrés y Gaspar, se encarga de un nuevo
planteamiento del sistema en términos mecánicos, de forma que se tenga al final del proyecto una
plataforma física del robot que tenga los sensores y actuadores necesarios en condiciones para su
desempeño óptimo para el proyecto. Esto significa tres puntos importantes:
Ubicación de los sensores del robot para poner en sus mejores puntos de operación, en
particular, los rangos de profundidad óptimos de las cámaras, y ubicación de los sensores de
posición.
Ubicación de los actuadores del robot para maximizar los grados de libertad de este. Esto se
refiere al brazo robótico, y el análisis de las posiciones posibles en el robot de forma que pueda
hacer lo deseado (poder agarrar un objeto desde el suelo).
Estimación de los niveles de corriente en el robot. Esto es particularmente importante en el
brazo, que consiste de múltiples servomotores, que deben funcionar cada uno haciendo fuerza,
por lo tanto pasan grandes corrientes (en términos de cercanía con las corrientes máximas) por
los servomotores y más importante, por la tarjeta controladora de éstos.
Se analizó el posicionamiento de los sensores, desarrollando fórmulas simples que definan
restricciones geométricas para la ubicación del sensor Kinect en el robot, dado su rango mínimo de
operación.
En base al análisis anterior se determinó que el sensor Kinect no satisface los requerimientos de
poder ver el entorno (para la navegación del robot) y el brazo juntos satisfactoriamente. Por ello el
tutor propuso la incorporación de un sensor extra, que se detallará más adelante, orientado al
control del brazo, mientras que se deja el sensor Kinect dedicado exclusivamente a navegación.
Con el requerimiento del nuevo sensor incorporado, se creó un modelo geométrico para el robot,
que se describirá con más detalle en la sección 4.2 de resultados. Con este modelo se pueden
probar distintas configuraciones del robot, en términos de posiciones (alturas, ángulos) de sus
piezas, de forma que se puede hacer el flujo de trabajo como se muestra en la Ilustración 10.
Se confeccionó un modelo geométrico usando el programa Autodesk 3Ds Max, con el que se logró
analizar de forma cualitativa la configuración mecánica propuesta. Este modelo rescata la idea
principal de invertir el brazo, de forma que pueda agarrar objetos del suelo, el sensor Kinect en la
parte superior del robot, y el sensor Carmine en la parte inferior. Se propone una suerte de
experimento para el modelo, que se puede probar con el software, que permite mover piezas
(como el brazo) simplemente moviéndolas con el mouse, respetando todas las restricciones
mecánicas impuestas en el modelo, como las articulaciones del brazo.
Con las especificaciones de altura del modelo confeccionado, se implementaron los cambios
propuestos por el modelo, esto es subir la plataforma superior del robot, en la que se ubicarán las
cámaras (Kinect y Carmine) y ubicar en una nueva plataforma media el brazo invertido. Como el
Planteamiento de
requerimientos
mecánicos
Análisis con modelo
geométrico
¿Satisface restricciones
de visión?
Disposición física
del sistema
No
Sí
FIN
Ilustración 10: Diagrama de flujo de rediseño mecánico
modelo geométrico especificó, la plataforma media tiene una forma alargada, distinta de las otras,
para asegurar que el brazo pueda tocar el suelo.
3.2 SUB-GRUPO DE INVESTIGACIÓN
Es necesario tener una base adecuada de conocimiento sobre los métodos de aprendizaje reforzado
disponibles así como aprovechar los más destacados entre ellos para los propósitos del proyecto.
Para esto se partió de la base del Algoritmo TExplore que fue sugerido por el Profesor Pablo
Guerrero1 debido a que toma muchos elementos de otros algoritmos y los mejora, obteniéndose un
algoritmo en tiempo real que requiere de menos exploración para tener buenos resultados.
Adicionalmente, en TExplore se hacer referencia a muchos otros algoritmos interesantes por sus
características o porque son modificados en TExplore, de forma que también sirve como índice de
búsqueda sobre el tema.
Los autores del algoritmo TExplore crearon un paquete [9] de ROS que implementa su algoritmo
más algunos otros, para que sirva a modo de ejemplo, prueba, y comparación de diferentes
alternativas en ambientes robóticos reales o simulados2.
Para poder llevar a cabo el proyecto es necesario integrar tanto TExplore como la plataforma ROS
(Robot Operative System) [10] de forma que se use el dominio de estados del brazo robótico. El
dominio actual de TExplore es un mundo de simulación basado en la exploración, por lo que es
necesario ajustar parámetros para nuestro dominio particular, que consiste en un estado formado
por las componentes de posición de cada juntura del brazo, y sus posibles movimientos.
El paquete de ROS de TExplore incluye los siguientes sub-paquetes, de los que se detallarán los
principales elementos a continuación:
3.2.1 RL_COMMON
Define archivos interfaces base que deben ser implementadas por agentes, entornos,
modelos y planificadores, ubicadas principalmente en el archivo core.hh.
3.2.1.1 Experiencia
1 Profesor del DCC tutor en el proyecto. 2 ROS tiene integración nativa con el simulador Gazebo.
struct experience { std::vector<float> s; int act; float reward; std::vector<float> next; bool terminal; };
Se define una tupla de tipos de datos donde
corresponde al estado inicial, corresponde a la acción realizada, corresponde a la recompensa
obtenida y corresponde al estado final de la transición. Con esta tupla se actualiza el modelo y un
booleano indica si la transición fue terminal.
3.2.1.2 StateActionInfo
Es el retorno del modelo cuando se le consulta por sus predicciones para un par estado/acción. Se compone de un booleano que indica si es una transición conocida, un float que predice la recompensa, un float que predice la probabilidad de término y un mapeo de estados a floats que da la probabilidad de los siguientes estados.
3.2.1.3 Agent
La clase Agent es una interfaz para los agentes que se quieran implementar. Sus métodos principales son:
first_action(estado): Se llama para la primera acción en un episodio y retorna la acción a ejecutar.
next_action(recompensa, estado): como first_action pero para los estados intermedios.
last_action(recompensa): como first_action pero para los estados terminales.
seedExp(experiencia[]): sirve para proveer de experiencias al agente.
3.2.1.4 Environment
class Agent { public: virtual int first_action(const std::vector<float> &s) = 0; virtual int next_action(float r, const std::vector<float> &s) = 0; virtual void last_action(float r) = 0; virtual void setDebug(bool d) = 0; virtual void seedExp(std::vector<experience> seeds) {}; virtual void savePolicy(const char* filename) {}; virtual ~Agent() {}; };
struct StateActionInfo { bool known; float reward; float termProb; int frameUpdated; // map from outcome state to probability std::map< std::vector<float> , float> transitionProbs; };
La clase Environment es una interfaz para los entornos que se quieran implementar. Sus métodos principales son:
sensation(): retorna el estado actual.
terminal() indica si el estado actual es terminal o no.
apply(acción): Para que un agente actúe en el entorno debe llamarlo. Retorna la recompensa.
getSeedings(): Retorna las experiencias para inicializar al agente.
getNumActions(): Entrega el número de acciones disponibles.
3.2.1.5 MDPModel
Esta clase modela el proceso de decisión de Markov.
updateWithExperiences(experiencia[]): actualiza el modelo con un vector de experiencias adicionales.
updateWithExperience(experiencia): actualiza el modelo con una experiencia adicional.
getStateActionInfo(estado, accion, StateActionInfo&): retorna la predicción del modelo (StateActionInfo) para el par estado/acción consultado.
getCopy(): retorna una copia del modelo.
class MDPModel { public: virtual bool updateWithExperiences(std::vector<experience> &instances) = 0; virtual bool updateWithExperience(experience &instance) = 0; virtual float getStateActionInfo(const std::vector<float> &state, int action, StateActionInfo* retval) = 0; virtual MDPModel* getCopy() = 0; virtual ~MDPModel() {}; };
class Environment { public: virtual const std::vector<float> &sensation() const = 0; virtual float apply(int action) = 0; virtual bool terminal() const = 0; virtual void reset() = 0; virtual int getNumActions() = 0; virtual void getMinMaxFeatures(std::vector<float> *minFeat, std::vector<float> *maxFeat) = 0; virtual void getMinMaxReward(float *minR, float *maxR) = 0; virtual bool isEpisodic(){ return true; }; virtual std::vector<experience> getSeedings(){ std::vector<experience> e; return e; } ; virtual void setSensation(std::vector<float> s){}; virtual ~Environment() {}; };
3.2.1.6 Planner
Interfaz para planificadores, los métodos principales son:
updateModelWithExperience(estado, acción, siguiente estado, recompensa, terminal): actualiza el modelo del agente con nueva experiencia.
planOnNewModel(): se llama cuando el modelo cambia. Calcula la nueva política óptima. getBestAction(estado): retorna la major acción para el estado dado.
3.2.2 RL_MSGS
Definición de mensajes de ROS para comunicar agentes y entornos. Se muestran los principales
mensajes en la Ilustración 11:
Ilustración 11: Mensajes de comunicación entre agente y entorno
3.2.2.1 Mensajes del agente al entorno
Nodo Agente
Nodo Entorno
Nodo
sensor
Nodo
odometría
Nodo
actuador
Nodo
navegación
RLStateReward
RLEnvDescription
RLExperimentInfo
(opcional)
RLAction
class Planner { public: virtual void setModel(MDPModel* model) = 0; virtual bool updateModelWithExperience(const std::vector<float>& last, int act, const std::vector<float>& curr, float reward, bool terminal) = 0; virtual void planOnNewModel() = 0; virtual int getBestAction(const std::vector<float> &s) = 0; virtual void savePolicy(const char* filename) {}; virtual void setSeeding(bool seeding) {}; virtual void setFirst() {}; std::vector<float>::iterator random_max_element(std::vector<float>::iterator start, std::vector<float>::iterator end) {…}; virtual ~Planner() {}; Random rng; };
RLAction: Envía al entorno la acción que el agente ha seleccionado (como número entero).
RLExperimentInfo: Entrega información sobre los resultados del último episodio del
experimento. Entrega el número del episodio, la suma de las recompensas, y el número de
acciones.
3.2.2.2 Mensajes del entorno al agente
RLEnvDescription: Describe el entorno, enviando el título, el número de acciones, el número de
estados, el rango de cada característica del estado, la máxima recompensa en tras una acción,
el rango de las recompensas, si la tarea es episódica, y si es determinística o estocástica.
Figure 1: Archivo RLEnvDescription.msg
RLEnvSeedExperience: Entrega una tupla de experiencia al agente para su aprendizaje, e indica
si el estado es terminal.
RLStateReward: Entrega el nuevo estado del agente, la recompensa recibida en el último paso y
si la transición es terminal.
Cuando se crea el entorno los pasos de comunicación son:
1. Envía un mensaje RLEnvDescription al agente.
2. Enviar todas las muestras de experiencia al agente en una serie de mensajes
ELEnvSeedExperience.
3. Enviar un mensaje RLStateReward con el estado inicial del agente en el dominio. Luego debería
recibirse un mensaje RLAction para aplciar la acción sobre el entorno y volver a enviar un
mensaje RLStateReward con la actualización.
4. Cuando el episodio termina el entorno recibirá un mensaje RLExperimentInfo del agente y
reiniciara el dominio volviendo a enviar un mensaje RLStateReward con el estado inicial del
nuevo episodio.
# Message that contains details about an RL enviroment/task float32 num_actions float32 num_states #Optional information to describe the range of a continous state #Some RL algorithms may need this to discretize the state space float32[] min_state_range float32[] max_state_range #Info needed for r-max some other methods float32 max_reward float32 reward_range bool stochastic bool episodic string title
3.2.3 RL_AGENT
Librería con algunos agentes de aprendizaje reforzado incluyendo:
Q-Learning
Sarsa
Dyna
R-Max
TEXPLORE
Lo interesante de este paquete es que tiene una arquitectura general basada en modelos, lo que
significa que uno puede crear agentes pasando diferentes parámetros y combinando planificadores
con aprendedores de modelos.
Los aprendedores de modelos disponibles son:
tabular: modelo tabular normal de máxima verosimilitud.
tree: Árboles de decisión C4.5 discretos.
m5tree: árboles de regresión M5 continuos.
Los planificadores disponibles son:
Iteración de valor [2]
Iteración de política [2]
Barrido de prioridad [11]
UCT: método de planificación basado en ejemplos. [6]
UCT paralelo: planificación y aprendizaje del modelo ocurren en paralelo, por lo que el
agente puede seleccionar acciones en tiempo real.
UCT retrasado: provee el modelo con las últimas n acciones para trabajar en dominios con
retraso.
UCT paralelo retrasado: Combina los anteriores.
Cualquiera de las combinaciones de planificadores y aprendedores del modelo puede hacerse, y
adicionalmente se puede realizar la exploración de diferentes formas:
epsilon-greedy: toma una acción aleatoria con probabilidad épsilon. El resto actúa
codiciosamente.
greedy: Actúa codiciosamente.
Unknown: asigna bonus como R-MAX a los pares estado/acción desconocidos.
Variancenovelty: explora usando varianza y nuevos bonus de exploración como en [12]
3.2.4 RL_ENV
Librería con algunos entornos de aprendizaje reforzado usados en varios papers:
Taxi
Two room grid world
Four room grid world
Four room grid world with energy levels
Fuel World [3]
Mountain Car [2]
Cart Pole [2]
Robot Car Velocity Control simulation
Stock Trading
Light World
El paquete consta de un archivo principal que hace las llamadas env.cpp y 2 archivos para cada uno
de los entornos como por ejemplo FuelRooms.hh y FuelRooms.cc
3.2.5 RL_EXPERIMENT
Paquete que corre experimentos de aprendizaje reforzado sin usar los mensajes de ROS, sino
que llamando a las funciones directamente. No es el caso deseado por lo que no se ahondará en
él.
3.2.6 PRUEBAS PRELIMINARES
Haciendo pruebas preliminares con el paquete se pudo poner a correr un ejemplo que demuestra el
funcionamiento del algoritmo. Cabe destacar que el sistema funciona bajo Ubuntu 12.04 LTS y ROS
Fuerte.
Comando Agente: Para lanzar un agente de tipo TExplore, con las condiciones por defecto
como se muestran en el desarrollo original del autor [3]
rosrun rl_agent agent --agent texplore --planner parallel-uct --
actrate 20
Comando entorno: Para lanzar el entorno de prueba “two rooms” con transiciones de tipo
estocástico.
rosrun rl_env env --env tworooms --stochastic
Comandos resultados: ejecutados en orden permiten imprimir, plotear y almacenar los
resultados del experimento actualmente activo. Los resultados son en tiempo real por lo
que irán entregando nuevos datos continuamente.
rostopic echo /rl_env/rl_state_reward rxplot /rl_agent/rl_experiment_info/episode_reward rosbag record /rl_agent/rl_action /rl_agent/rl_experiment_info
3.2.7 ADAPTACIÓN ALGORITMO
El nodo “rl_env” maneja el ambiente en que se mueve el agente y entrega la información necesaria
al agente para que se desenvuelva en este, mediante mensajes de ROS. Este es el nodo que habría
que modificar principalmente agregando un nuevo ambiente al catálogo ya existente y definiendo
su estructura específica, en lenguaje C++.
Una vez decidida la disposición física final del robot se puede proceder con el diseño de los tríos
estado, acción, recompensa que definen el problema de aprendizaje reforzado.
En el espectro de acciones no se consideran todas las posiciones del motor, dado que algunas de
ellas llevan a posiciones ocupadas por otras piezas, u posiciones indeseables, por lo que se
restringirá el dominio dependiendo del estado actual, lo que también ayuda a disminuir el tamaño
del problema a resolver y mejorar la convergencia del algoritmo.
4 RESULTADOS
4.1 INVESTIGACIÓN Se investigó sobre el algoritmo TExplore y sus principales componentes algorítmicas, para
comprender el funcionamiento de la estructura propuesta. Para esto se realizaron las siguientes
presentaciones con el profesor tutor:
1. TExplore (Sección 9.2): En esta presentación se detallaron los principales componentes del
algoritmo y se identificaron las áreas de dominio. Adicionalmente se comprobaron los
parámetros a elegir, sus valores óptimos en cada caso y el tipo de experimentos usados.
2. UCT (Sección 9.3): En esta presentación se vio en detalle el funcionamiento del algoritmo de
planeación sobre árboles usado por TExplore, se comprendieron sus ventajas y desventajas,
así como sus parámetros específicos.
3. Bosques aleatorios (Sección 9.4): En esta presentación se comprendieron los conceptos de
esta técnica, la forma de construcción de los árboles aleatorios, y las propiedades de
generalización que ofrecen.
4.2 MODELO GEOMÉTRICO Los resultados del modelo se muestran en la Ilustración 12 y la Ilustración 13.
Ilustración 12: Modelo de robot para rediseño mecánico
Los componentes referenciados en la Ilustración 12 son los siguientes:
4. Sensor de profundidad Kinect.
5. Sensor de profundidad Carmine.
6. Brazo robótico.
7. Cubos de prueba.
8. Plataformas que conforman el cuerpo del robot.
El sensor Kinect se subió a una plataforma ubicada a 50 cm del suelo, y se ocupara principalmente
para tareas de navegación. Esto es pues no es posible ocuparlo en ocuparlo en la realimentación del
brazo pues su rango mínimo es de 70 cm.
Para la realimentación del brazo se ocupó el sensor Carmine, ubicado en la plataforma superior de
manera invertida, de manera que quede la punta brazo dentro del cono de visión. Este sensor tiene
un rango mínimo de 30 cm, lo que lo hace ideal para esta tarea.
Con respecto al brazo robótico, este fue trasladado a una plataforma ubicada a 30cm de altura,
luego fue invertido para cumplir con las especificaciones, que eran poder agarrar objetos del suelo.
Se considera la posibilidad de modificar el gripper del brazo para que se ajustara de mejor forma a
los objetos a agarrar, usando un material más adherente como lo es el caucho.
Los cubos de prueba han sido pensados para hacer la prueba más básica para demostrar la
funcionalidad del proyecto. Luego se podrán hacer pruebas con otros objetos.
Ilustración 13: Vista de cámara inferior
Es necesario trabajar paralelamente en las pruebas de hardware. En este aspecto se testearan
diferentes configuraciones espaciales de los componentes de acuerdo a los resultados obtenidos
por el grupo de rediseño mecánico. El éxito de estas pruebas será medido principalmente según dos
aspectos: la medición del campo de visión efectivo del robot que permite el reconocimiento de
objetos; y la comprobación del alcance efectivo del brazo mecánico, esto incluye no solo el alcance
máximo de la extremidad sino que su capacidad de alcanzar y coger objetos dentro del campo de
visión del robot.
Dependiendo del éxito de las pruebas anteriores se procederá a unir sus resultados llevando al
robot a un entorno real, donde se espera que el autómata sea capaz de aprender mediante la
exploración de su entorno a realizar la tarea deseada, esto es, reconocer objetos dentro de su
campo de visión y manipularlos mediante el uso de su brazo mecánico.
4.3 CONSTRUCCIÓN El modelo construido se muestra en la Ilustración 14 y la Ilustración 15. La plataforma agregada es
de madera terciada de 6 [mm] de espesor, y los soportes son barras de aluminio de 20 [cm] de alto.
La construcción del modelo se hizo tratando de mantener la modularidad del robot, de forma que
no cambie drásticamente lo que el robot implementa hasta ahora, que es básicamente el
movimiento del brazo y la visión con el sensor Kinect.
Ilustración 14: Robot Turtlebot modificado
Al modelo construido falta agregar el sensor Carmine que estará fijo mirando el brazo, y será el
encargado de obtener el feedback de cómo se mueve. Este será incorporado una vez que se liberen
los fondos.
El brazo utiliza 5 servos, que están alimentados por la batería presente en el Romba, que son 12
pilas AA de 1,5 V. El robot tiene una autonomía de 2 a 3 horas, considerando un comportamiento
típico de los motores y 1,5 horas si el robot se mueve constantemente, según las pruebas de
laboratorio.
Los servos del brazo son los Dynamixel AX-12A (ver Ilustración 16), y son capaces de levantar un
peso máximo de 600 g, lo suficiente como para levantar un mug lleno. Las especificaciones del servo
se muestran en la Tabla 2.
El controlador usado es el Arbotix Robocontroller, típicamente usado en aplicaciones de este tipo,
que contiene un chip AVR ATMEGA644P de 16mhz compatible con Arduino, el cual se programa
usando una interfaz FTDI y el Arduino IDE.
Ilustración 15: Comparación entre robot original y robot modificado
AX-12A Stats
Voltaje de operación 12V
Torque 15.3 kg·cm
212 oz·in
Velocidad Vacío 59 RPM
0.169sec/60°
Masa 55g
Dimensiones 32 x 50 x 40 mm
Resolución 0.29°
Relación de reducción 1/254
Angulo operacional 300°
Voltaje de operación 9-12V (Recomendado11.1V)
Corriente máxima 900 mA
Corriente sin carga 50 mA
Temperatura en operación -5°C ~ 85°C
Protocolo TTL Half Duplex Async Serial
Módulos Máximos 254 direcciones validas
Velocidad Com 7343bps ~ 1Mbps
Feedback Posición Yes
Feedback Temperatura Yes
Feedback Voltaje salida Yes
Feedback Voltaje entrada Yes
PID Yes
Material Engranajes y cuerpo plasticos
Motor Motor bobinado
Manual AX-12A manual
Lista de Controladores Arbotix Robocontroller
USB2Dynamixel
CM-530
CM-700
CM-5
CM2+ Tabla 2: Especificaciones del servo AX-12a, utilizado en el brazo robótico.
Ilustración 16: Servo utilizado en el brazo robótico, modelo AX-12A.
4.4 PRUEBAS DEL SISTEMA Se realizaron las siguientes pruebas al sistema,
Ángulo máximo del brazo tocando el suelo: 87º, con respecto al frente.
Ángulo máximo del brazo sin tocar el suelo: 126º, con respecto al frente.
Ángulo máximo del servo 2: 36,87º, con respecto a la horizontal.
Angulo mínimo del servo 2: -87º, con respecto a la horizontal.
Ángulo máximo del servo 3: 52º, con respecto a la horizontal.
Ángulo mínimo del servo 3: -90º, con respecto a la horizontal.
Distancia máxima de alcance en la plataforma media: 11 [cm], respecto al borde de la
plataforma media (la plataforma en la que está apoyada el brazo) y 18[cm] con el brazo en
diagonal.
En la Ilustración 17 se muestra una aproximación del alcance que provee el brazo en el suelo.
Ilustración 17: Alcance del brazo en el suelo
5 DISCUSIÓN DE RESULTADOS
5.1 MODELO GEOMÉTRICO Con este modelo se pudo ver la factibilidad de la solución propuesta, esto es el que el sensor
inferior del robot puede ver exitosamente la punta del brazo, y que el brazo, invertido, puede
alcanzar los objetos que están a nivel del suelo. También se vio que para cierta altura de los objetos,
el sensor inferior falla en poder verlos, pero eso se sale de los experimentos propuestos (agarrar
objetos del suelo) y por tanto del rango de operación del robot.
5.2 CONSTRUCCIÓN En la Ilustración 14 y la Ilustración 15 se ve la construcción del robot, según el modelo geométrico.
Por asuntos de presupuesto, no se implementó el sistema para el control del sensor Carmine, ya
que este no se ha comprado aún y depende de los fondos del grupo de robótica del DCC. De todas
formas, en la última Ilustración 15 se ve que brazo del robot alcanza el suelo, de forma que cumple
el cometido más importante del rediseño mecánico, que es permitir al brazo del robot tomar
objetos del suelo.
Es importante destacar que, dada la simplicidad del modelo geométrico, que consideró el robot
como un conjunto de plataformas circulares de iguales dimensiones, fue necesario, al hacer la
18[cm]
87º 87º
nueva plataforma, tener en cuenta este efecto, y para ello se hizo que la nueva plataforma fuera
una réplica de las que el robot tenía (hexágonos), pero dejando un lado más corto y más alejado del
centro del hexágono, de forma que el borde quedase a la misma altura que la base del robot, y así
la construcción del modelo respetara el modelo geométrico. Esto implica también que para ubicar
el sensor Carmine, que según la Ilustración 12 está en el borde del robot, será necesario hacer una
nueva plataforma, de la misma forma que la construida para este informe, que permita ubicar el
sensor al borde del robot, o modificar la actual para este efecto.
Para la integración del sensor Carmine es necesario diseñar piezas de un tamaño apropiado que
permitan sostener el sensor, así como también instalar el servo que lo mueve, sin embargo estas
piezas no fueron implementadas dada la incertidumbre respecto de las dimensiones exactas del
sensor, y sus puntos de sujeción. Esta información no fue posible obtenerla en esta etapa, sin
embargo una vez comprado el sensor no habrían dificultades dado que si se conocían sus
dimensiones externas, y fueron tomadas en cuenta en el rediseño físico realizado.
6 EVALUACIÓN ECONÓMICA El costo de la evaluación económica está dado principalmente por la nueva cámara para el robot, y
un servomotor para darle el tilt, y los costos se muestran en la Tabla 3.
Subtotal
Cámara RGBD
200 [US$]
Modelo Precio unitario Cantidad
Carmine 1.09 200 [US$] 1
http://www.primesense.com/developers/get-your-sensor/
Servo motor
5920 [CLP]
Modelo Precio unitario Cantidad
MCI-RBT-00966 5920 [CLP] 1
http://www.olimex.cl/product_info.php?products_id=966&product__name=S
ervo_Peque%F1o
Soportes
3000 [CLP] Modelo Precio unitario Cantidad
Barras de aluminio 750 [CLP] 4
Plataforma 1000 [CLP] Modelo Precio unitario Cantidad
Madera 1000 [CLP] 1
Total3 111720 [CLP]
Tabla 3: Costos de piezas para rediseño mecánico
Los costos del proyecto están dentro del marco de costos del Laboratorio de Robótica del DCC.
3 Al costo del dólar al día de entrega de este informe, que es 509 [CLP]
7 CONCLUSIONES
El desarrollo del modelo tridimensional del turtlebot logro una disminución en las horas de trabajo
que podrían haber surgido en la hora de la fabricación del prototipo, esto debido a que se
resolvieron todos los problemas de implementación y factibilidad dentro del modelo, así como
también la simulación del área visual de las cámaras y los problemas de colisión del brazo en la
nueva posición.
El nuevo diseño del robot considera más piezas de las que originalmente contenía, y esto hace que
el consumo de energía del robot sea mayor al que este mismo es capaz de otorgar, lo que se
manifiesta en que los motores se mueven más lento y tienen poca fuerza. Se rediseñara, en un
futuro, la manera en que la batería entrega energía a los nuevos componentes, ya sea aumentando
el tipo de baterías para que entreguen más corriente, o agregando más de estas, junto a un cambio
en la electrónica. Es bueno considerar que en la parte inferior del robot hay espacio para colocar
otra batería como la que usa actualmente, lo que simplifica el trabajo futuro.
Adicionalmente se podría considerar colocar barreras en los bordes de la plataforma de la que
cuelga el brazo, para así poder transportar objetos con mayor seguridad evitando la caída de estos.
El cambio en la posición original de la Kinect hace necesaria una calibración del sistema de
movimiento y navegación del turtlebot. Dado que esto no es parte de los objetivos del proyecto, no
se realizara, sin embargo es un trabajo necesario para que el robot navegue autónomamente.
Queda pendiente la implementación del algoritmo de aprendizaje reforzado. El objetivo es que el
robot sea capaz de aprender a manipular cubos con su brazo. Como consecuencia de esto último, se
espera que el robot sea capaz de estimar las proporciones de su brazo, y relacionarlas con la
ubicación espacial del objeto en cuestión. Para la implementación de este algoritmo es necesario
modificar al menos uno de los nodos del paquete “rl-texplore-ros-pkg” que maneja el ambiente en
que se mueve el agente, de forma de que incorpore las restricciones dadas por la nueva
configuración física implementada.
8 BIBLIOGRAFÍA [1] Richard Bellman, "A Markovian Decision Process," Indiana University Mathematics Journal, vol.
6, no. 4, pp. 679--684, Abril 1957.
[2] Richard S. Sutton and Andrew G. Barto, Reinforcement Learning: An Introduction , Primera ed.,
Thomas Diettrich, Ed. Cambridge, Reino Unido: MIT press, 1998.
[3] Todd Hester, "TEXPLORE: Temporal Difference Reinforcement Learning for Robots and Time-
Constrained Domains," Universidad de Texas, Austin, Estados Unidos, Tesis doctoral 2012.
[4] Todd Hester, "Real Time Targeted Exploration in Large Domains," in The Ninth International
Conference on Development and Learning, Michigan, 2010, pp. 1-6.
[5] Todd Hester and Peter Stone, "TEXPLORE: Real-Time Sample-Efficient Reinforcement
Learning for Robots," Machine Learning Journal, vol. 90, no. 3, pp. 385-429, Marzo 2013.
[6] Levente Kocsis and Csaba Szepesvári, "Bandit based monte-carlo planning," in ECML'06
Proceedings of the 17th European conference on Machine Learning, Berlin, 2006, pp. 282-293.
[7] Todd Hester and Peter Stone, "Generalized model learning for reinforcement learning in
factored domains," in AAMAS '09 Proceedings of The 8th International Conference on
Autonomous Agents and Multiagent Systems - Volume 2, Richland, 2009, pp. 717-724.
[8] Willow Garage. (2013, Abril) Willow Garage - Turtlebot. [Online].
http://www.willowgarage.com/turtlebot
[9] Todd Hester. (2012, Julio) rl-texplore-ros-pkg. [Online]. http://www.ros.org/wiki/rl-texplore-
ros-pkg
[10] Willow Garage. (2013, Abril) Ros.org. [Online]. http://www.ros.org/wiki/
[11] Atkenson C. Moore A, "Prioritized sweeping: Reinforcement learning with less data and less
real time. ," Machine Learning, vol. 13, no. 1, pp. 103-130, Octubre 1993.
[12] Todd Hester and Peter Stone, "Intrinsically Motivated Model Learning for a Developing
Curious Agent," in The Eleventh International Conference on Development and Learning (ICDL),
San Diego, Noviembre 2012.
9 ANEXOS
9.1 PLANIFICACIÓN DEL PROYECTO
9.1.1 CARTA GANTT La planificación del proyecto está dada por la carta Gantt de la Tabla 1.
Tabla 4: Carta Gantt del proyecto
9.1.2 CURVA S
La estimación de las horas dedicadas al proyecto se muestra en la curva S de la Ilustración 18:
Curva S del proyecto
Ilustración 18: Curva S del proyecto
-20
0
20
40
60
80
100
120
140
160
0 2 4 6 8 10 12 14 16
Ho
ras
Acu
mu
lad
as
Semana
Curva S
Informe de Avance I Informe de Avance 2 Informe Final
9.2 PRESENTACIÓN DE DIAPOSITIVAS SOBRE TEXPLORE:
9.3 PRESENTACIÓN SOBRE UCT (UPPER CONFIDENCE BOUNDS APPLIED TO TREES)
9.4 PRESENTACIÓN SOBRE ÁRBOLES Y BOSQUES ALEATORIOS