Agentes autónomos con Python

Los agentes autónomos, impulsados por la inteligencia artificial, son entidades capaces de tomar decisiones y realizar acciones sin intervención humana directa. En este artículo, exploraremos el fascinante mundo de los agentes autónomos utilizando Python, un lenguaje de programación poderoso y versátil.

¿Qué son los Agentes Autónomos?

Los agentes autónomos son programas de software o sistemas físicos diseñados para interactuar con su entorno y tomar decisiones de manera autónoma. Estos agentes son esenciales en campos como la robótica, el aprendizaje automático y la inteligencia artificial. Su capacidad para adaptarse y aprender de su entorno los convierte en herramientas valiosas para abordar problemas complejos.

Características Principales de los Agentes Autónomos:

1. Toma de Decisiones: Los agentes autónomos pueden tomar decisiones basadas en la información disponible y en los objetivos establecidos.
2. Sensores y Percepción: Utilizan sensores para recopilar información sobre su entorno y entender el contexto en el que operan.
3. Actuadores y Acciones: Los actuadores permiten a los agentes autónomos realizar acciones físicas o virtuales en respuesta a sus decisiones.

Implementando un agente autónomo

A continuación vamos a revisar los pasos para implementar un agente autónomo:
Comentarios:

1. Importar Librerías:

   • from collections import deque: Importar deque de la librería collections para una implementación eficiente de una cola.

from collections import deque

2. Clase AutonomousVacuumCleaner:
   La clase AutonomousVacuumCleaner, que implementa la lógica de la aspiradora, contiene los siguientes métodos:
   • __init__: Inicializa la aspiradora con el espacio proporcionado y establece la posición inicial.
   • show_state: Muestra el estado actual del espacio.
   • has_dirt: Verifica si hay suciedad en alguna parte del espacio.
   • clean_cell: Marca la celda actual como “Limpio”.
   • move: Mueve la aspiradora en la dirección especificada, actualizando la posición y limpiando la celda.

Y se ve de la siguiente manera:

class AutonomousVacuumCleaner:
    def __init__(self, space):
        self.space = space
        self.position = (0, 0)  # Initial position

    def show_state(self):
        for row in self.space:
            print(row)
        print()

    def has_dirt(self):
        return any("Dirty" in row for row in self.space)

    def clean_cell(self):
        x, y = self.position
        self.space[x][y] = "Clean"

    def move(self, direction):
        x, y = self.position
        if direction == "up" and x > 0:
            x -= 1
        elif direction == "down" and x < len(self.space) - 1:
            x += 1
        elif direction == "left" and y > 0:
            y -= 1
        elif direction == "right" and y < len(self.space[0]) - 1:
            y += 1

        self.position = (x, y)
        self.clean_cell()

3. Función bfs_cleaning:
   La función BFS (Breadth-First Search) búsqueda en amplitud, nos ayuda a optimizar el proceso de limpieza mediante la búsqueda de una secuencia óptima de pasos de acuerdo con la configuración del espacio que se desea limpiar, configurado previamente mediante la matriz proporcionada, sus actividades consisten en:
   • Inicializa la aspiradora, define movimientos posibles, y configura la cola BFS y los estados visitados.
   • Realiza BFS hasta que se encuentra una solución o se alcanza el límite máximo de iteraciones.
   • Copia el estado de la aspiradora para cada posible movimiento y verifica si el nuevo estado no ha sido visitado previamente.
   • Retorna la secuencia óptima de movimientos si se encuentra; de lo contrario, retorna None.

La implementación de la función es la siguiente:

def bfs_cleaning(space, max_iterations=1000):
    cleaner = AutonomousVacuumCleaner(space)
    movements = ["up", "down", "left", "right"]
    frontier = deque([(cleaner, [])])  # Queue for BFS, each element is a pair (state, sequence of movements)
    visited_states = set()

    iterations = 0
    while frontier and iterations < max_iterations:
        current_state, current_sequence = frontier.popleft()
        cleaner, current_sequence = current_state, current_sequence

        if not cleaner.has_dirt():
            return current_sequence

        for movement in movements:
            cleaner_copy = AutonomousVacuumCleaner([row.copy() for row in cleaner.space])
            cleaner_copy.position = cleaner.position
            cleaner_copy.move(movement)

            state_tuple = tuple(tuple(row) for row in cleaner_copy.space)
            if state_tuple not in visited_states:
                visited_states.add(state_tuple)
                new_sequence = current_sequence + [movement]
                frontier.append((cleaner_copy, new_sequence))

        iterations += 1

    return None  # No solution found within the limit

4. Ejecución:
   Para ejecutar la implementación de nuestro agente autónomo de una aspiradora debemos realizar lo siguiente:
   • Crea una matriz de 3x3 como el espacio de limpieza.
   • Encuentra la secuencia óptima usando BFS.
   • Ejecuta la secuencia óptima, mostrando el estado en cada paso e indicando si la habitación está limpia.

Y en código se vería así:

# Create a space for the vacuum cleaner (3x3 matrix)
cleaning_space = [
    ["Dirty", "Dirty", "Dirty"],
    ["Dirty", "Clean", "Dirty"],
    ["Dirty", "Dirty", "Dirty"]
]

# Find the optimal sequence of movements
optimal_sequence = bfs_cleaning(cleaning_space)

# Execute the optimal sequence
if optimal_sequence:
    print("Optimal sequence as found")
    print(optimal_sequence)
    vacuum_cleaner = AutonomousVacuumCleaner(cleaning_space)
    for movement in optimal_sequence:
        vacuum_cleaner.show_state()
        vacuum_cleaner.move(movement)

    print("Room is clean!")
else:
    print("No solution found within the limit.")

Resultado

Tomando en cuenta que el inicio de la limpieza en la configuración del espacio a limpiar (matriz) comienza en la posición (0, 0), la ejecución de nuestro agente autónomo proporcionará una salida similar a la siguiente:

Optimal sequence as found
['up', 'down', 'down', 'right', 'right', 'up', 'up', 'left']
['Dirty', 'Dirty', 'Dirty']
['Dirty', 'Clean', 'Dirty']
['Dirty', 'Dirty', 'Dirty']

['Clean', 'Dirty', 'Dirty']
['Dirty', 'Clean', 'Dirty']
['Dirty', 'Dirty', 'Dirty']

['Clean', 'Dirty', 'Dirty']
['Clean', 'Clean', 'Dirty']
['Dirty', 'Dirty', 'Dirty']

['Clean', 'Dirty', 'Dirty']
['Clean', 'Clean', 'Dirty']
['Clean', 'Dirty', 'Dirty']

['Clean', 'Dirty', 'Dirty']
['Clean', 'Clean', 'Dirty']
['Clean', 'Clean', 'Dirty']

['Clean', 'Dirty', 'Dirty']
['Clean', 'Clean', 'Dirty']
['Clean', 'Clean', 'Clean']

['Clean', 'Dirty', 'Dirty']
['Clean', 'Clean', 'Clean']
['Clean', 'Clean', 'Clean']

['Clean', 'Dirty', 'Clean']
['Clean', 'Clean', 'Clean']
['Clean', 'Clean', 'Clean']

['Clean', 'Clean', 'Clean']
['Clean', 'Clean', 'Clean']
['Clean', 'Clean', 'Clean']

Room is clean!

Podemos ver que todas las celdas de la configuración han sido limpiadas (clean).

Los agentes autónomos son entidades capaces de operar de manera independiente en entornos específicos, tomando decisiones y realizando acciones sin intervención humana directa. Estos agentes se utilizan en una variedad de campos, desde robótica y inteligencia artificial hasta sistemas autónomos en vehículos y aplicaciones industriales. Aquí hay un resumen de las características clave de los agentes autónomos:

1. Capacidad de Toma de Decisiones:

   • Los agentes autónomos tienen la capacidad de evaluar información de su entorno y tomar decisiones basadas en objetivos y reglas predefinidas.

2. Sensores y Percepción:

   • Utilizan sensores para recopilar datos del entorno, lo que les permite percibir y comprender su situación. Estos sensores pueden incluir cámaras, micrófonos, radares, entre otros.

3. Actuadores y Acciones:

   • Los actuadores permiten a los agentes realizar acciones físicas o virtuales en respuesta a sus decisiones. Ejemplos de actuadores incluyen motores, brazos robóticos, o incluso interfaces de software para interactuar con sistemas digitales.

4. Entrenamiento y Aprendizaje:

   • Algunos agentes autónomos pueden aprender y adaptarse a su entorno a lo largo del tiempo. El aprendizaje puede ser supervisado, no supervisado o por refuerzo, permitiendo a los agentes mejorar su desempeño con la experiencia.

5. Aplicaciones Diversas:

   • Se aplican en una amplia gama de campos, como la robótica doméstica, vehículos autónomos, sistemas de control industrial, asistentes virtuales, videojuegos y más.

6. Algoritmos y Estrategias:

   • Los agentes autónomos a menudo implementan algoritmos de búsqueda, planificación y control para alcanzar sus objetivos de manera eficiente. Estrategias como la búsqueda de amplitud, búsqueda heurística y aprendizaje automático son comunes.

7. Comunicación entre Agentes:

   • En entornos complejos, los agentes autónomos pueden necesitar comunicarse entre sí para coordinar acciones y lograr objetivos más grandes. Esto es especialmente evidente en sistemas multiagente.

8. Ética y Responsabilidad:

   • A medida que los agentes autónomos se vuelven más avanzados, surgen cuestiones éticas y de responsabilidad. La programación y el comportamiento de estos agentes deben ser cuidadosamente diseñados para evitar resultados no deseados o peligrosos.