por supuesto que los agentes existen por sí mismos, ellos pueden también existir en
colecciones de agentes, hay una cantidad de colecciones ya construidas que
seguramente ya vieron si es que ya trabajaron con ellas; por ejemplo los
parches, tortugas y vínculos son conjuntos de agentes que automáticamente incluyen
todos los parches, todas las tortugas y todos los vínculos, pero hay otras
colecciones nativas como tortugas-aquí que los agentes pueden usar para obtener todas
las tortugas en el parche actual o vecinos en el vínculos, que busca vínculos entre
los vecinos en la unidad anterior y toma a todos los agentes que están vinculados con
ese agente; los linajes de los agentes también construyen conjuntos de
colecciones creadas; entonces los influenciadores y los imitadores o los
regulares, como los llamamos en la unidad anterior, son conjuntos de agentes y
pueden tener sus propias propiedades, los influenciadores y los imitadores
también creamos conjuntos de agentes en forma dinámica usando comandos como "with"
o "turtles-on"; entonces en el modelo básico de la inferencia del tráfico,
podemos decir, hagamos que los autos rápidos sean tortugas cuya velocidad es
mayor que 0.5 y podemos pedirle a los autos rápidos que hagan algo y así podemos
manipular a los conjuntos de agentes en forma directa
acá tenemos el modelo básico del tráfico, que ya vimos en la unidad 1 y una de las
cosas que quiero explorar es cómo podemos en verdad asignar a los agentes y crearlos
en forma dinámica sobre la marcha para este modelo; una cosa que podemos, por
ejemplo, hacer es dejar que el modelo corra por un rato y luego, podemos ver la
velocidad de los agentes; podemos en verdad tratar de identificar cuales de los
autos son los que se mueven más rápido, entonces podemos pedirle a NetLogo que
asigne a los autos rápidos aquellas tortugas con una velocidad mayor que 0.3
ok? y podemos pedirle a los autos rápidos que asignen sus medidas a 2; en este caso
estamos creando dinámicamente un conjunto de agentes, que nos permite manipular ese
conjunto de agentes
los conjuntos de agentes tienen relación también con las listas y entonces quiero
mencionar eso en forma breve; las listas pueden tener cualquier tipo de elemento
pero los conjuntos de agentes pueden solamente tener agentes; dicho sea de paso
las no-tortugas son un conjunto de agentes que contiene ninguna tortuga, es el
conjunto de agentes vacío podríamos decir y podemos convertir de un conjunto de
agentes a listas para adelante y para atrás; la mejor forma de hacerlo es que si
tienen una lista de agentes, ustedes pueden recorrer todos los elementos de esa
lista usando un comando que se llama foreach de NetLogo que recorre una lista y
pueden pedirle a cada elemento que haga algo y el signo de pregunta es un símbolo
de uso reservado en NetLogo que define lo que sea que ocurre en esa iteración con el
elemento iterado, entonces para cada elemento en la lista, vaya al 1er elemento
que puede ser 0 y luego le dice que le ordene a la tortuga 0 que haga algo,
perdón, a-list puede ser la tortuga 0, tortuga 1 y tortuga 3, digale a la tortuga
0 que haga algo y así sucesivamente
usando esto podemos movernos por una lista que hemos creado a partir de un conjunto
de agentes de tortugas; entonces en el modelo básico del tráfico de tortugas
puede que querramos mirar en una lista que nos ordene la velocidad de las tortugas e
incremente aquellos que se basan en aquella velocidad, puede que nos de con
diferentes medidas o algo así
qué pasa si queremos usar una lista y hacer algo con esa lista; una cosa que
podemos llegar a querer hacer; los conjuntos de agentes pueden en verdad ser
ordenados en sí mismos, son conjuntos y no tienen un orden intrínseco, entonces
puede que querramos ordenarlos al conjunto de agentes en una lista y usar esa lista
ordenada para hacer algo; entonces reiniciemos el modelo básico el tráfico y
dejemos que corra por un tiempo y lo que vamos a hacer es dejar que la lista de
velocidad
se ordene en base a la velocidad
de las tortugas; esto va a crear una lista donde cada elemento es una tortuga o un
agente y el conjunto de agentes de las tortugas y que quede ordenado por la
velocidad; lo que vamos a hacer es crear una nueva variable que se llame nueva
medida y le vamos a pedir a cada, vamos a recorrer cada elemento de la lista de
velocidad y pedirle a cada una de las tortugas que asigne su medida a la nueva
medida y entonces vamos a tener que asignar la nueva medida a la nueva medida
más 1
y lo que esto debería hacer
tengo todo puesto en el lugar adecuado, debería estar haciendo este código en la
ventana de código; le dice a cada tortuga que se agrande en relación a la última,
esto es muy grande, quedaron en verdad muy grandes; podemos de hecho reiniciarlo y
volver al comando y llamarlo y asignarle la nueva medida como igual a 0.1, ahí ya
estamos, ahora se ve mucho mejor; entonces la medida de la tortuga está directamente
relacionada con la velocidad y lo que hicimos y como lo hicimos fue creando una
lista que ordene las tortugas de acuerdo a su velocidad y luego asignar el tamaño
basados en esa lista
es importante que nos demos cuenta que cuando creamos un conjunto de agentes este
permanece estático hasta que se lo recrea o hasta que se actualiza, en otras
palabras cuando asignamos los autos más rápidos, el conjunto de agentes, si nos
ponemos a correr el modelo, los autos no pueden tener una velocidad que sea mayor a
0.3, que en forma automática le agregamos al conjunto de agentes, podemos decir
asigne a los autos rápidos, a las tortugas con la velocidad mayor a 0.3 otra vez
y esto tiene 2 efectos profundos, 1 que nos permite dar un orden y también en ver
cual es el modo más eficiente de crear un conjunto de agentes y vamos a mirar eso en
el modelo que está preconstruido que se encuentran en la biblioteca de modelos de
NetLogo
entonces quiero que veamos la biblioteca de modelos de NetLogo y bajar y encontrar
IABM textbook y en el capítulo 5, si miran ven que hay un modelo que se llama
ordenando conjuntos de agentes y vamos a empezar con el ordenamiento del conjunto
de agentes; este modelo empieza de forma muy sencilla, genera un montón de tortugas
y les asgina una medida al azar entre 0 y 2 y
aquí vamos, las tortugas diferentes
en promedio, podemos ver que hay 53 tortugas pequeñas ahora mismo y pequeño en
este contexto quiere decir que son tortugas menores a 1, es eso lo que
esperamos?
si ejecutamos el código de "go" y lo que hace ese código es les pide a las tortugas
que tienen un tamaño menor a 1, las tortugas pequeñas, que identifiquen una
tortuga grande y si encuentran esa tortuga grande, entonces le pide que su medida sea
más pequeña y le va a asignar su propio color de tortuga, que es rojo, si el
conjunto de agentes se actualiza en forma dinámica, eso significa que todas las
tortugas pequeñas van a ser ahora rojas, pero debido a que no lo son, debido al
hecho que no se actualiza hasta que no volvemos a este comando donde le pide a
las tortugas que tienen un tamaño menor a 1; algunas de las tortugas van a ser más
pequeñas que 1, ahora, debido a que hemos agrandado su tamaño y entonces quedarán en
color azul, entonces hacemos click en setup y en go y podemos ver que el número
de tortugas pequeñas es en verdad es que son casi todas ahora, pero sólamete 55 son
rojas, si hacemos click en go otra vez, ahora todas ellas son pequeñas, pero sólo
93 son rojas; este es sólamente depende de cómo se crea el conjunto de agentes para
poder obtener lo que esperamos que hagan las tortugas
vamos a jugar con esta noción de conjunto de agentes un poco más y usemos el
conjunto de agentes en forma eficiente; este modelo, miremos un poco inicialmente
crea un conjunto, no crea un conjunto de tortugas para nada, simplemente trabaja
con los parches y asigna a todos los parches que sean o verdes o rojos y la 1ra
codificación del go, les pide a todos los parches que tengan el color rojo que
cuenten los parches que tengan color verde y si ese número es mayor que 5 entonces le
asigna plabel con un valor al azar de 5 y viceversa a los parches verdes los cuenta
y asigna el plabel a un valor diferente, hacemos click en setup y en go y podemos
ver estos valores
esto es un cálculo arbitrario, no tiene mucho sentido, pero por el otro lado el
go2 hace lo mismo que el go1 pero es más eficiente debido a que calcula cada cada
conjunto de agentes sólo 1 vez, ahora ustedes pueden preguntar por qué esto es
así? si miran, dentro de cada ask hay un conteo de los parches que tienen pcolor
igual a verde y cada tortuga cuyo pcolor es rojo tiene que ser contada en forma
separada; pero lo que podemos hacer en vez de eso es en verdad crear un conjunto con
todos los parches rojos y un conjunto con todos los parches verdes y vamos a
simplificar, le pedimos a los parches rojos que cuente los parches verdes y a
los parches verdes que cuente los parches rojos; esto resulta en que es más
eficiente debido a que almacena el cálculo del conjunto de agentes, de otro modo
tendríamos que calcular en el momento, cuando no se cambian los colores, hay
cambios en la forma de negociar, esto es importante, incrementar la eficiencia del
modelo NetLogo
no se observa porque corre muy rápido pero go2 es bastante más rápido que go1 y así
pueden correr el modelo las veces que quieran
go3 por el otro lado explora qué sucede con los colores de los parches cuando
cambian, en este caso le pedimos a los parches que son rojos que cuente los
parches que son verdes si son mayores a 5 y que asigne el color a verde y viceversa
para los verdes; uno puede esperar esto que simplemente vaya y venga, luego del
mismo patrón de color, que es el opuesto, debido a que está cambiando, el color
verde si hay muchos rojos, perdón el color verde si hay muchos verdes, si es rojo es
el color rojo, si es verde y hay muchos rojos; entonces todo cambia debido a que
hay más que este 5; pero lo que sucede en verdad, como pueden ver, es que todo el
mundo se vuelve verde y por qué sucede esto? sucede debido a que la 1ra porción
de código corre y todos los parches rojos se vuelven verdes y en la 2da porción de
código corre y debido a que no hay ningún parche rojo, ninguno de ellos se vuelve al
rojo; lo que en verdad queremos hacer y esto está en el go5, el comando go4, es
que en vez de ello almacena todos los parches al comienzo y luego los usa y
podemos ver la conducta como cambia, setup y go, ok, ahora podemos ver como
cambia, todos los verdes se vuelven rojos y todos los rojos se vuelven verdes y
cambian de uno a otro lado y eso es lo que esperábamos; entonces es importante notar
como creamos nuestros conjuntos de agentes y qué es lo que hacen, dicho sea de paso
este procedimiento que está acá, que se usa con este comando, en verdad muestra
los resultados para poder compararlos entre el go1 y el go2, podemos correr test
1-2 y esto va a correr cada go1 unas 100 veces y luego nos muestra los resultados
de ellos en términos de cuanto tiempo tarda en NetLogo para correr, si miran al
código en verdad usa el mismo código de reset-time, del que ya hablamos, pero en
este caso nos permite calcular la cantidad de tiempo que le lleva a NetLogo correr
algo, ustedes pueden reinciar el reloj y luego calcular el tiempo que tarda después
de una cierta cantidad; entonces como pueden ver, la prueba de go1 tarda 17
segundos en NetLogo para correr unas 100 veces, en cambio go2 tarda 1/4 de un
segundo o menos; entonces los conjuntos de agentes son importantes y debemos pensar
en ellos cuando creamos nuestros modelos para asegurarnos de que corra en forma
eficiente, gracias