• Saltar al contenido principal
  • Skip to secondary menu
  • Saltar a la barra lateral principal
  • Saltar al pie de página
  • Inicio
  • Secciones
    • Ciencia de datos
    • Criptografía
    • Herramientas
    • Machine Learning
    • Noticias
    • Opinión
    • Productividad
    • Programación
      • JavaScript
      • Julia
      • Matlab
      • Python
      • R
  • Programación
    • JavaScript
    • Julia
    • Matlab
    • Python
    • R
  • Herramientas
    • Método D’Hondt – Atribución de escaños
  • Noticias
  • Boletín
  • Contacto
  • Tienda
    • Libros
    • Equipamiento de oficina
    • Equipamiento en movilidad
    • Tiendas afiliadas
      • AliExpress
      • Amazon
      • Banggood
      • GeekBuying
      • Lenovo

Analytics Lane

Ciencia e ingeniería de datos aplicada

  • Ciencia de datos
  • Machine Learning
  • Python
  • Pandas
  • NumPy
  • Matlab
  • Julia
  • Excel
  • IA Generativa

Epsilon-Greedy para el Bandido Multibrazo (Multi-Armed Bandit)

febrero 26, 2021 Por Daniel Rodríguez Deja un comentario
Tiempo de lectura: 6 minutos

La semana pasada hemos visto cómo resolver el problema del Bandido Multibrazo mediante un test A/B. Con el que se jugó con cada uno de los bandidos una cantidad de veces dada hasta que se estaba seguro de cuál era el mejor de los bandidos. Esta aproximación no es eficiente, ya que en muchos casos se puede saber rápidamente cuáles son los peores, por lo que se puede plantear otra estrategia más eficaz. Estrategia como Epsilon-Greedy en la que se selecciona el mejor hasta ese momento de los bandidos salvo un porcentaje de veces en las que se juega de forma aleatoria. Ocasiones con las que se explorar el resto de las soluciones.

Tabla de contenidos

  • 1 Epsilon-Greedy
  • 2 Clase con la implementación del bandido
  • 3 Implementación de la estrategia Epsilon-Greedy
    • 3.1 Jugadas aleatorias
    • 3.2 Seleccionar el mejor bandido
  • 4 Resultados
  • 5 Conclusiones

Epsilon-Greedy

La estrategia Epsilon-Greedy es realmente sencilla. En esta, en primer lugar, se decide si se juega con el mejor bandido, aquel que ha devuelto la mayor recompensa promedio hasta el momento, o de forma completamente aleatoria. El porcentaje de veces en las que la estrategia jugará de forma aleatoria se seleccionará mediante un valor epsilon. Así se obtendrá la mejor recompensa con la información disponible, al mismo tiempo que es posible explorar otras soluciones con las tiradas aleatorias.

Esta simple estrategia permite maximizar la recompensa ya que jugará preferentemente con el bandido que ha ofrecido la mayor recompensa hasta ese momento. Sin tener que esperar a probar con cada uno de los bandidos la cantidad de veces que ha definido al principio.

Consistencia en nombres y orden en TypeScript: la base de un código mantenible aplicado a tslane
En Analytics Lane
Consistencia en nombres y orden en TypeScript: la base de un código mantenible aplicado a tslane

Es importante tener en cuenta que si el valor de epsilon es bajo el algoritmo no podrá identificar rápidamente la mejor solución. Pero si el valor es alto, una vez identificada la mejor solución, se seguirá jugando una cantidad de veces elevada con una solución que no es la óptima. Por lo que el valor de epsilon es un compromiso que tiene que tener en cuenta tanto la exploración y la explotación.

Publicidad


Clase con la implementación del bandido

Para implementar esta estrategia se puede usar la clase bandido que se creó la semana pasada. Solamente que en esta ocasión es necesario contar con un atributo que nos indique la recompensa media histórica del bandido. Algo que se puede hacer con el método mean() de NumPy, aunque a medida que crece el número de jugadas esto puede no ser eficiente. Por lo que se puede actualizar el valor en cada una de las jugadas utilizando la siguiente fórmula

\overline{x_n} = \left(1-\frac{1}{n}\right) * \overline{x_{n-1}} + \frac{x_n}{n}

donde \overline{x_n} es la recompensa media del bandido que se ha obtenido en la tirada n y x_n es la recompensa obtenida en la tirada n. Lo que evita tener que calcular la media de vectores con miles de valores después de cada tirada.

Así se puede agregar dos atributos a la clase mean para almacenar la media y plays para almacenar el número de jugadas. Siendo ahora probability el atributo en el que almacena la probabilidad de que el bandido devuelva una recompensa. Lo que nos deja la clase Bandit de la siguiente forma.

import numpy as np

class Bandit:
    """
    Implementación de un Bandido Multibrazo (Multi-Armed Bandit) basado
    en una distribución binomial

    Parameters
    ----------
    probability : float
        Probabilidad de que el objeto devuelva una recompensa
    
    Attributes
    ----------
    rewards : array
        Históricos de recompensas generadas por el bandido
    mean : float
        Recompensa media histórica del bandido
    plays : integer
        Cantidad de veces que ha jugado con el bandido

    Methods
    -------
    pull :
        Realiza una tirada en el bandido
        
    """
    def __init__(self, probability):
        self.probability = probability
        self.rewards = []
        self.mean = 0
        self.plays = 0
        
        
    def pull(self):
        # Obtención de una nueva recompensa
        reward = np.random.binomial(1, self.probability)
        
        # Agregación de la recompensa al listado
        self.rewards.append(reward)
        
        # Actualización de la media (es más rápido que usar la función media de la recompensa)
        self.plays += 1
        self.mean = (1 - 1.0/self.plays) * self.mean + 1.0/self.plays * reward
        
        return reward

Ya no es necesaria el atributo rewards, pero se puede dejar para usar poder seguir usando esta clase con el código de la semana pasada.

Implementación de la estrategia Epsilon-Greedy

Ahora que se ha actualizado la clase se puede implementar la estrategia. Para ello primero se tiene que decidir el porcentaje de veces que se jugará de forma aleatoria, por ejemplo, un 5%. Una vez hecho esto solamente se tiene que seleccionar un número aleatorio y en base a este seleccionar el bandido. Siendo la selección espilon veces de forma aleatoria y el resto de las veces seleccionando el que tiene la mejor recompensa hasta el momento.

Publicidad


Jugadas aleatorias

Para las jugadas en las que se seleccione aleatoriamente se puede usar el método numpy.random.choice(). Lo que devolverá un número al azar cada vez.

Seleccionar el mejor bandido

La primera idea para seleccionar el mejor bandido puede ser usar el método nunpy.argmax() de las medias. Aunque en este punto es importante tener en cuenta que los bandidos devuelven la recompensa con una frecuencia muy baja. Por lo que en las primeras jugadas todos tendrán una recompensa media igual a cero. Así, en caso de usar el método argmax con un vector de ceros, lo que tendremos en las primeras tiradas, devolverá siempre el primero, el cual puede que no sea el mejor.

Para solucionar este problema una opción puede ser seleccionar aleatoriamente uno de los bandidos en caso de que exista un empate entre ellos. Lo que ayudará a explorar más rápidamente las opciones al principio. Para lo que se puede combatir el uso de numpy.where() para identificar las posición de los bandidos con el valor máximo y numpy.random.choice(), para seleccionar uno de estos.

Así se pude crear la siguiente implementación para resolver el problema.

np.random.seed(0)
    
bandits = [Bandit(0.02), Bandit(0.04), Bandit(0.06), Bandit(0.08), Bandit(0.10)]
evaluations = 8500
eps = 0.05

rewards = [] 

for i in range(evaluations):
    p = np.random.random()
    
    if p < eps:
        j = np.random.choice(len(bandits))
    else:
        means = [b.mean for b in bandits]
        max_bandits = np.where(means == np.max(means))[0]
        j = np.random.choice(max_bandits)
        
    rewards.append(bandits[j].pull())
    
total_reward = np.sum([np.sum(bandit.rewards) for bandit in bandits])
avg_reward = total_reward / evaluations

Publicidad


Resultados

De cara a comparar con la solución obtenida la semana pasada con un test A/B en primer lugar vamos a ver cómo funciona el algoritmo con 8500 jugadas. En este caso se obtiene una recompensa media de 9.6%, bastante superior al 8,1% que se observó la semana pasada con el test A/B. Además, se puede comprobar la evolución de la recompensa media, para lo que se puede imprimir la recompensa media en cada jugada. Lo que se puede obtener con el siguiente código.

import matplotlib.pyplot as plt

cumulative_average = np.cumsum(rewards) / (np.arange(len(rewards)) + 1)

plt.plot(range(len(rewards)), cumulative_average)
Recompensa media acumulada
Recompensa media acumulada

Lo que muestra que, en torno a las 1000 jugadas, la recompensa media obtenida ya se acerca a la final. Lo que indica que en este punto el algoritmo se ha decidido por jugar mayoritariamente con el bandido que ofrece una recompensa del 10%. Una conclusión a la que se ha llegado bastante más rápido que mediante el uso del test A/B.

En las primeras jugadas se puede ver una recompensa promedio por encima del máximo, pero es algo que puede suceder debido a la aleatoriedad de las recompensas. Aunque esto se corrige rápidamente a medida que aumentan el número de jugadas.

Posiblemente en torno a las 1000 jugadas ya no sea necesario explorar otros resultados. Pero el algoritmo seguirá jugando un 5% de las veces aleatoriamente, algo que veremos la semana que viene cómo se puede mejorar.

Conclusiones

Hoy hemos visto cómo solucionar un problema de Bandido Multibrazo utilizando para ello la estrategia de Epsilon-Greedy. Una estrategia que es sencilla de implementar y ofrece buenos resultados. La próxima semana veremos cómo mejorar el algoritmo para evitar que siga jugando aleatoriamente cuando ya se ha decidido por un bandido.

Imagen de klimkin en Pixabay

¿Te ha parecido de utilidad el contenido?

¡Puntúalo entre una y cinco estrellas!

Puntuación promedio 5 / 5. Votos emitidos: 1

Ya que has encontrado útil este contenido...

¡Síguenos en redes sociales!

¡Siento que este contenido no te haya sido útil!

¡Déjame mejorar este contenido!

Dime, ¿cómo puedo mejorar este contenido?

Publicidad


Publicaciones relacionadas

  • Consistencia en nombres y orden en TypeScript: la base de un código mantenible aplicado a tslane
  • Análisis de Redes con Python
  • Nuevo calendario de publicaciones: más calidad, mejor ritmo
  • Probabilidad básica: cómo entender el azar en nuestra vida diaria
  • Cómo eliminar las noticias en Windows 11 y recuperar tu concentración
  • Publicaciones de verano 2025: los trucos más populares, ahora en vídeo
  • Cómo enviar correos desde PowerShell utilizando Brevo: Guía paso a paso para automatizar tus notificaciones
  • Nueva herramienta disponible: Calculadora del Método D’Hondt para la atribución de escaños
  • Cómo enviar correos desde Python utilizando Brevo: Automatiza tus notificaciones con scripts eficientes

Publicado en: Ciencia de datos Etiquetado como: Aprendizaje por refuerzo, Machine learning, Multi-Armed Bandit

Interacciones con los lectores

Deja una respuesta Cancelar la respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

I accept the Terms and Conditions and the Privacy Policy

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.

Barra lateral principal

Suscríbete a nuestro boletín

Suscríbete al boletín semanal para estar al día de todas las publicaciones.

Política de Privacidad

Analytics Lane en redes sociales

  • Amazon
  • Bluesky
  • Facebook
  • GitHub
  • Instagram
  • Mastodon
  • Pinterest
  • RSS
  • Telegram
  • Tumblr
  • Twitter
  • YouTube

Publicidad

Entradas recientes

¡Nuevo video! Gráficos de barras en Matplotlib sin complicarte

julio 17, 2025 Por Daniel Rodríguez

¡Nuevo video! Iterar filas en Pandas sin romperte la cabeza

julio 15, 2025 Por Daniel Rodríguez

¡Nuevo video! Encuentra la posición en listas como un PRO

julio 10, 2025 Por Daniel Rodríguez

Publicidad

Es tendencia

  • Obtención de valores únicos de una columna con Pandas publicado el mayo 8, 2019 | en Python
  • Cómo encontrar la posición de elementos en una lista de Python publicado el abril 12, 2021 | en Python
  • Combinar varios archivos Jupyter Notebook en uno publicado el noviembre 21, 2022 | en Python
  • Gráficos de barras en Matplotlib publicado el julio 5, 2022 | en Python
  • pandas Pandas: Cómo iterar sobre las filas de un DataFrame en Pandas publicado el septiembre 13, 2021 | en Python

Publicidad

Lo mejor valorado

4.9 (24)

Seleccionar filas y columnas en Pandas con iloc y loc

4.6 (16)

Archivos JSON con Python: lectura y escritura

4.4 (14)

Ordenación de diccionarios en Python mediante clave o valor

4.7 (13)

Operaciones de filtrado de DataFrame con Pandas en base a los valores de las columnas

4.5 (10)

Diferencias entre var y let en JavaScript

Publicidad

Comentarios recientes

  • Piera en Ecuaciones multilínea en Markdown
  • Daniel Rodríguez en Tutorial de Mypy para Principiantes
  • Javier en Tutorial de Mypy para Principiantes
  • javier en Problemas con listas mutables en Python: Cómo evitar efectos inesperados
  • soldado en Numpy básico: encontrar la posición de un elemento en un Array de Numpy

Publicidad


Footer

Analytics Lane

  • Acerca de Analytics Lane
  • Boletín de noticias
  • Contacto
  • Libros
  • Lo más popular
  • Noticias
  • Tienda
  • Tiendas afiliadas

Secciones

  • Ciencia de datos
  • Criptografía
  • Herramientas
  • Machine Learning
  • Opinión
  • Productividad
  • Programación
  • Reseñas

Sobre de Analytics Lane

En Analytics Lane tratamos de explicar los principales conceptos de la ciencia e ingeniería de datos con un enfoque práctico. Los principales temas tratados son ciencia de datos, ingeniería de datos, inteligencia artificial, machine learning, deep learning y criptografía. Además, también se habla de los principales lenguajes de programación y herramientas utilizadas por los científicos e ingenieros de datos.

Copyright © 2018-2025 Analytics Lane ·Términos y condiciones ·Política de Cookies ·Política de Privacidad ·Herramientas de privacidad ·Contacto