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