Q Learning: todo lo que necesita saber sobre el aprendizaje por refuerzo

y son algunos de los dominios que se encuentran entre las principales palabras de moda en la industria y por una buena razón. La IA creará 2,3 millones de puestos de trabajo para 2020, teniendo en cuenta que su principal objetivo es permitir que las máquinas imiten el comportamiento humano. Extraño, ¿no? Entonces, hoy vamos a discutir Q Learning, el componente básico del aprendizaje por refuerzo en el siguiente orden:

es una maestría un posgrado

• ¿Qué es el aprendizaje por refuerzo?
• Proceso de Q-Learning
• Ecuación de Bellman
• Proceso de decisión de Markov
• Demostración de Q-Learning: NumPy

¿Qué es el aprendizaje por refuerzo?

Echemos un vistazo a nuestro día a día. Realizamos numerosas tareas en el medio ambiente y algunas de esas tareas nos brindan recompensas, mientras que otras no. Seguimos buscando diferentes caminos e intentamos descubrir qué camino conducirá a las recompensas y, en función de nuestra acción, mejoramos nuestras estrategias para lograr los objetivos. Esta, mis amigos, es una de las analogías más simples del aprendizaje por refuerzo.

Áreas clave de interés:

• Ambiente
• Acción
• Recompensa
• Estado

El aprendizaje por refuerzo es la rama del aprendizaje automático que permite a los sistemas aprender de los resultados de sus propias decisiones. Resuelve un tipo particular de problema en el que la toma de decisiones es secuencial y el objetivo es a largo plazo.

Proceso de Q-Learning

Comprendamos qué está aprendiendo Q con nuestro planteamiento del problema aquí. Nos ayudará a definir los componentes principales de una solución de aprendizaje por refuerzo, es decir, agentes, entorno, acciones, recompensas y estados.

Analogía de la fábrica de automóviles:

Estamos en una fábrica de automóviles llena de robots. Estos robots ayudan a los trabajadores de la fábrica transportando las piezas necesarias para ensamblar un automóvil. Estas diferentes partes están ubicadas en diferentes ubicaciones dentro de la fábrica en 9 estaciones. Las partes incluyen chasis, ruedas, tablero de instrumentos, motor, etc. Factory Master ha priorizado la ubicación donde se está instalando el chasis como la máxima prioridad. Echemos un vistazo a la configuración aquí:

Estados:

La ubicación en la que está presente un robot en una instancia particular se denomina estado. Ya que es fácil codificarlo en lugar de recordarlo por nombres. Asignemos la ubicación a números.

Comportamiento:

Las acciones no son más que los movimientos realizados por los robots a cualquier lugar. Considere, un robot está en la ubicación L2 y las ubicaciones directas a las que puede moverse son L5, L1 y L3. Comprendamos esto mejor si visualizamos esto:

Recompensas:

Se le dará una recompensa al robot por pasar directamente de un estado a otro. Por ejemplo, puede llegar a L5 directamente desde L2 y viceversa. Por lo tanto, se proporcionará una recompensa de 1 en cualquier caso. Echemos un vistazo a la tabla de recompensas:

Recuerde cuando el maestro de fábrica dio prioridad a la ubicación del chasis. Era L7, así que vamos a incorporar este hecho en nuestra tabla de recompensas. Por lo tanto, asignaremos un número muy grande (999 en nuestro caso) en la ubicación (L7, L7).

Ecuación de Bellman

Ahora suponga que un robot necesita ir del punto A al B. Escogerá el camino que producirá una recompensa positiva. Por eso, supongamos que proporcionamos una recompensa en términos de huella para que lo siga.

Pero, ¿qué pasa si el robot comienza desde algún punto intermedio donde puede ver dos o más caminos? Por tanto, el robot no puede tomar una decisión y esto sucede principalmente porque no posee un memoria . Aquí es donde entra en escena la ecuación de Bellman.

V (s) = máx (R (s, a) + & # 120632V (s '))

Dónde:

• s = un estado particular
• a = acción
• s '= estado al que pasa el robot desde s
• & # 120632 = factor de descuento
• R (s, a) = una función de recompensa que toma un estado (s) y una acción (a) y genera un valor de recompensa
• V (s) = valor de estar en un estado particular

Ahora el bloque debajo del destino tendrá una recompensa de 1, que es la recompensa más alta, pero ¿qué pasa con el otro bloque? Bueno, aquí es donde entra el factor de descuento. Supongamos un factor de descuento de 0,9 y completemos todos los bloques uno por uno.

cómo compilar un programa java

Proceso de decisión de Markov

Imagina que un robot está en el bloque naranja y necesita llegar al destino. Pero incluso si hay una ligera disfunción, el robot estará confundido acerca de qué camino tomar en lugar de subir.

Entonces necesitamos modificar el proceso de toma de decisiones. Tiene que Parcialmente aleatorio y En parte bajo el control del robot . En parte aleatorio porque no sabemos cuándo funcionará el robot y en parte bajo control porque todavía es decisión del robot. Y esto forma la base del proceso de decisión de Markov.

Un proceso de decisión de Markov (MDP) es un proceso de control estocástico de tiempo discreto. Proporciona un marco matemático para modelar la toma de decisiones en situaciones en las que los resultados son en parte aleatorios y en parte están bajo el control de quien toma las decisiones.

Entonces, usaremos nuestra ecuación de Bellman original y haremos cambios en ella. Lo que no sabemos es el siguiente estado, es decir. s ’. Lo que sabemos son todas las posibilidades de un giro y cambiemos la ecuación.

V (s) = max (R (s, a) + & # 120632 V (s '))

V (s) = máx (R (s, a) + & # 120632 &Sigma_{s ’}P (s, a, s ') V (s '))

P (s, a, s '): Probabilidad de mudarse de estado s a s ’ con accion a

&Sigma_{s ’}P (s, a, s ') V (s '): Expectativas de aleatoriedad del robot

V (s) = max (R (s, a) + & # 120632 ((0.8V (habitación_arriba)) + (0.1V (habitación_abajo) + ….))

Ahora, hagamos la transición a Q Learning. Q-Learning plantea la idea de evaluar la calidad de una acción que se lleva a cabo para pasar a un estado en lugar de determinar el posible valor del estado al que se está moviendo.

Esto es lo que obtenemos si incorporamos la idea de evaluar la calidad de las acciones para pasar a un estado determinado. De la Ecuación de Bellman actualizada si los eliminamos max componente, estamos asumiendo sólo una huella para una posible acción que no es más que el Calidad de la acción.

Q (s, a) = (R (s, a) + & # 120632 &Sigma_{s ’}P (s, a, s ') V (s '))

En esta ecuación que cuantifica la calidad de acción, podemos asumir que V (s) es el máximo de todos los valores posibles de Q (s, a). Así que reemplacemos v (s ') con una función de Q ().

Q (s, a) = (R (s, a) + & # 120632 &Sigma_{s ’}P (s, a, s ') max Q (s ’, a’))

Estamos a un paso de nuestra Ecuación final de Q Learning. Vamos a presentar un Diferencia temporal para calcular los valores Q con respecto a los cambios en el medio ambiente a lo largo del tiempo. Pero, ¿cómo observamos el cambio en Q?

TD (s, a) = (R (s, a) + & # 120632 &Sigma_{s ’}P (s, a, s ') max Q (s ’, a’)) - Q (s, a)

Recalculamos el nuevo Q (s, a) con la misma fórmula y le restamos el Q (s, a) previamente conocido. Entonces, la ecuación anterior se convierte en:

Q_t(s, a) = Q_t-1(s, a) + α TD_t(s, a)

Q_t(s, a) = Valor Q actual

Q_t-1(s, a) = Valor Q anterior

Q_t(s, a) = Q_t-1(s, a) + α (R (s, a) + & # 120632 max Q (s ’, a’)_–Q_t-1(s, a))

Demostración de aprendizaje Q: NumPy

Voy a usar NumPy para demostrar cómo funciona Q Learning.

Paso 1: Importaciones, parámetros, estados, acciones y recompensas

import numpy as np gamma = 0.75 # Factor de descuento alfa = 0.9 # Tasa de aprendizaje location_to_state = {'L1': 0, 'L2': 1, 'L3': 2, 'L4': 3, 'L5': 4, ' L6 ': 5,' L7 ': 6,' L8 ': 7,' L9 ': 8} acciones = [0,1,2,3,4,5,6,7,8] recompensas = np.array ( [[0,1,0,0,0,0,0,0,0], [1,0,1,0,0,0,0,0,0], [0,1,0,0, 0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,1,0,0,0,0,0,1,0] , [0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,1,0], [0,0,0,0, 1,0,1,0,1], [0,0,0,0,0,0,0,1,0]])

Paso 2: Asignar índices a ubicaciones

state_to_location = dict ((estado, ubicación) para la ubicación, estado en location_to_state.items ())

Paso 3: Obtenga una ruta óptima usando Q Learning Process

def get_optimal_route (start_location, end_location): rewards_new = np.copy (recompensas) End_state = location_to_state [end_location] rewards_new [End_state, End_state] = 999 Q = np.array (np.zeros ([9,9])) # Q- Proceso de aprendizaje para i en el rango (1000): # Recogiendo un estado aleatorio current_state = np.random.randint (0,9) # Python excluye el límite superior jugables_actions = [] # Iterando a través de la nueva matriz de recompensas para j en el rango ( 9): if rewards_new [current_state, j]> 0: jugable_actions.append (j) # Elija una acción aleatoria que nos lleve al siguiente estado next_state = np.random.choice (jugable_actions) # Calcular la diferencia temporal TD = rewards_new [current_state , next_state] + gamma * Q [next_state, np.argmax (Q [next_state,])] - Q [current_state, next_state] # Actualización del Q-Value usando la ecuación de Bellman Q [current_state, next_state] + = alpha * TD # Inicialice la ruta óptima con la ubicación de inicio route = [start_location] #Inicialice next_location con la ubicación de inicio next_location = star t_location # No sabemos sobre el número exacto de iteraciones necesarias para llegar a la ubicación final, por lo tanto, el bucle while será una buena opción para iterar while (next_location! = end_location): # Obtener el estado de inicio start_state = location_to_state [start_location] # Obtener el valor Q más alto correspondiente al estado inicial next_state = np.argmax (Q [start_state,]) # Obtuvimos el índice del siguiente estado. Pero necesitamos la letra correspondiente. next_location = state_to_location [next_state] route.append (next_location) # Actualizar la ubicación inicial para la siguiente iteración start_location = next_location ruta de retorno

Paso 4: imprima la ruta

imprimir (get_optimal_route ('L1', 'L9'))

Salida:

cómo crear archivos de registro en java

Con esto, llegamos al final de Q-Learning. Espero que haya conocido el funcionamiento de Q Learning junto con las diversas dependencias que existen, como la diferencia temporal, la ecuación de Bellman y más.

Edureka's lo hace competente en técnicas como el aprendizaje supervisado, el aprendizaje no supervisado y el procesamiento del lenguaje natural. Incluye capacitación sobre los últimos avances y enfoques técnicos en inteligencia artificial y aprendizaje automático, como aprendizaje profundo, modelos gráficos y aprendizaje por refuerzo.