Concepto de agente

01 · Punto de partida

Del objeto pasivo al agente autónomo

En el Tema 1 poblamos un mundo con puntos que caminaban al azar. Funcionó para ver encuentros, pero esos puntos no decidían nada: eran partículas, no agentes.

Un agente aparece cuando el individuo mira su entorno y elige qué hacer. Un auto que frena porque ve al de adelante, una persona que se queda en casa porque ve muchos enfermos cerca, una familia que se muda porque no se siente en minoría: todos perciben, comparan y actúan.

• ¿Qué información guarda el agente sobre sí mismo?
• ¿Qué puede percibir y qué le queda invisible?
• ¿Con qué regla transforma lo que ve en una acción?
• ¿Cómo cambia el mundo después de su acción?

02 · Definición

¿Qué hace agente a un agente?

Cuatro rasgos mínimos separan a un agente de una variable o de un objeto pasivo:

Sin estos tres verbos no hay ABM: si el individuo no percibe, es una partícula; si no decide, es un dato; si no actúa, es un espectador.

03 · Distinción

Agente frente a objeto y variable

En programación todo parece un objeto. La diferencia está en quién inicia la acción:

Estado

Lo que el agente recuerda de sí: posición, energía, salud, opinión. (Tema 3)

Percepción

El recorte del mundo que puede ver: radio, vecinos, celdas. (Tema 11)

Regla

El si-entonces que convierte percepción en acción. (Tema 6)

Acción

El cambio que produce: moverse, contagiar, comprar, opinar. (Tema 5)

04 · Mecanismo

El ciclo que repetiremos 50 temas

Cada paso de simulación es una vuelta a este circuito, agente por agente:

1. 1
   Percibir.

   Medir lo cercano: ¿cuántos vecinos veo? ¿A qué distancia? ¿Qué estado tienen?

2. 2
   Decidir.

   Aplicar la regla: si hay hacinamiento, moverse; si hay contagio cerca, aislarse; si hay minoría, mudarse.

3. 3
   Actuar.

   Ejecutar el cambio: actualizar posición, salud u opinión, y así modificar lo que otros percibirán.

05 · Representación en Python

Un agente es una clase con tres métodos

El diccionario del Tema 1 alcanza para guardar datos. La clase expresa mejor la autonomía: el agente lleva sus datos y su regla encima.

import math

class Agente:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def percibir(self, otros, radio=0.2):
        vecinos = 0
        for o in otros:
            if o is self:
                continue
            d = math.hypot(self.x - o.x, self.y - o.y)
            if d < radio:
                vecinos += 1
        return vecinos

yo = Agente(0.5, 0.5)
mundo = [yo, Agente(0.55, 0.52), Agente(0.9, 0.9)]
print("vecinos:", yo.percibir(mundo, radio=0.2))

Probá cambiar el radio a 0.05 o mover el tercer agente a (0.52, 0.5): la percepción cambia sin tocar la regla.

Agregar la decisión

Percibir sin decidir es espiar. Cerramos el ciclo con una regla explícita: si hay más de 2 vecinos, el agente se declara incómodo y propone moverse.

import math, random

class Agente:
    def __init__(self, x, y, umbral=2):
        self.x = x
        self.y = y
        self.umbral = umbral

    def percibir(self, otros, radio=0.2):
        return sum(
            1 for o in otros if o is not self
            and math.hypot(self.x - o.x, self.y - o.y) < radio
        )

    def decidir(self, otros, radio=0.2):
        return "moverse" if self.percibir(otros, radio) > self.umbral else "quedarse"

random.seed(0)
poblacion = [Agente(random.random(), random.random()) for _ in range(6)]
for a in poblacion:
    print(a.decidir(poblacion))

06 · Exploración

Laboratorio: lo que ve un agente

El punto dorado es tu agente. El círculo punteado es su radio de percepción: solo cuenta a los vecinos dentro. Si los vecinos percibidos superan el umbral de tolerancia, decide moverse; si no, se queda. Movete los controles y observá cómo la misma multitud produce decisiones opuestas.

El agente focal está en el centro. Los puntos amarillos están dentro de su radio y los grises quedan fuera de su mundo percibido. La flecha indica la decisión: quedarse (gris) o moverse (amarillo).

Preguntas para explorar

1. Con 14 vecinos y umbral 3, achicá el radio al mínimo. ¿Por qué el agente se queda aunque el mundo esté lleno?
2. Subí el umbral a 10 con radio grande. ¿Qué cambió: el mundo o la tolerancia del agente?
3. Pulsá Nueva disposición varias veces con los mismos valores. ¿La decisión es siempre la misma? ¿Qué nos dice sobre percepción y azar?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: crear un agente con estado

Ejecutá este agente con posición y energía. Luego bajá su energía en 1 como si actuar costara.

class Agente:
    def __init__(self, x, y, energia=10):
        self.x = x
        self.y = y
        self.energia = energia

yo = Agente(0.2, 0.8)
yo.energia -= 1
print(yo.x, yo.y, yo.energia)

Ejercicio 2: contar solo a los cercanos

Sin ejecutar primero: con radio 0.1, ¿cuántos vecinos percibe el agente en (0.5, 0.5) si los otros están en (0.55, 0.5) y (0.9, 0.9)? Comprobalo después.

import math

class Agente:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def percibir(self, otros, radio=0.1):
        return sum(1 for o in otros if o is not self
                   and math.hypot(self.x - o.x, self.y - o.y) < radio)

yo = Agente(0.5, 0.5)
mundo = [yo, Agente(0.55, 0.5), Agente(0.9, 0.9)]
print(yo.percibir(mundo, radio=0.1))

Ejercicio 3: escribir la regla completa

Agregá el método actuar: si decide moverse, el agente da un pasito aleatorio; si no, se queda. Probalo con umbral 0.

import math, random
random.seed(1)

class Agente:
    def __init__(self, x, y, umbral=0):
        self.x = x
        self.y = y
        self.umbral = umbral
    def percibir(self, otros, radio=0.3):
        return sum(1 for o in otros if o is not self
                   and math.hypot(self.x - o.x, self.y - o.y) < radio)
    def decidir(self, otros, radio=0.3):
        return "moverse" if self.percibir(otros, radio) > self.umbral else "quedarse"
    def actuar(self, otros, radio=0.3):
        if self.decidir(otros, radio) == "moverse":
            self.x = min(1.0, max(0.0, self.x + random.uniform(-0.05, 0.05)))
            self.y = min(1.0, max(0.0, self.y + random.uniform(-0.05, 0.05)))
        return (round(self.x, 3), round(self.y, 3))

a = Agente(0.5, 0.5)
b = Agente(0.52, 0.5)
print(a.decidir([a, b]), a.actuar([a, b]))

09 · Síntesis

Ideas para recordar

En el próximo tema estudiaremos el estado de un agente: qué guarda en su memoria y cómo ese estado condiciona lo que hará después.