• Author / Uploaded
• Aprender Libre

• Categories
• Python (Lenguaje de programación)
• Servidor (Informática)
• Inteligencia artificial
• Tecnología
• Lenguaje de programación

Citation preview

Python • DESARROLLO

Inteligencia Artificial y Python

Craig Toron

UN SISTEMA LLAMADO LINDA La inteligencia artificial es un campo abundante en buenas ideas, y LINDA es una de las mejores. Saquen todos sus tizas porque LINDA pone la pizarra. LINDA nos va a permitir crear un canal de comunicación entre programas que además de potente es muy sencillo. POR JOSÉ MARÍA RUIZ

L

o reconozco, me encantan los sistemas raros. Constantemente estoy echando vistazos al pasado buscando joyas escondidas en libros antiguos sobre inteligencia artificial. Y el artículo de este mes trata sobre uno de esos sistemas: LINDA. Fue diseñado como una arquitectura que permitiría a distintos programas intercambiar y colaborar. Desarrollado por David Gelernter y Nicholas Carriero, de la Universidad de Yale, su objetivo era simplificar esta tarea. Poner de acuerdo varios programas es algo extraordinariamente difícil. Existen muchos métodos, desde sistemas de red a procesos o hebras. Pero todos son complicados, y es aquí donde este sistema destaca: LINDA es sencillo y simple. La idea subyacente es la misma que ha

hecho del software libre un entorno tan dinámico. En lugar de hacer un gran diseño con niveles y controles de acceso, o sea, la famosa catedral de Eric S. Raymond, LINDA es más bien como un bazar. Crea un espacio donde unos programas «postean» tareas y otros programas las recogen y ejecutan. Así de simple. La idea está tomando cuerpo de nuevo y numerosos lenguajes de programación han comenzado a desarrollar implementaciones de LINDA. Por supuesto Python dispone de unas cuantas. Veamos cómo funciona.

La gran pizarra La idea detrás de LINDA se conoce en el entorno de la inteligencia artificial como sistema de pizarra. Se supone que existe

WWW.LINUX- MAGAZINE.ES

una gran pizarra a la que todo el mundo tiene acceso. Yo puedo llegar y poner una operación, digamos 2.71 + 3.1416, y me voy. Pasado un tiempo alguien llega, ve la operación escrita en la pizarra, la resuelve 5,8516 y se va. Al cabo de un rato yo vuelvo y, ¡oh sorpresa!, encuentro que la operación que iba a realizar ha sido realizada por alguien anónimo. Pues LINDA crea exactamente el mismo entorno. Existen un programa servidor linda_server que crea la gran pizarra. Los programas se conectan a él y pueden introducir una operación a realizar o bien realizar alguna de las operaciones presentes. Se supone que la información necesaria para realizar las operaciones debe estar presente en la pizarra, no podemos depender de información externa. De esta forma cualquiera que

Número 27

41

DESARROLLO • Python

encuentre la operación podrá llevarla a cabo sin contactar con nosotros. Los sistemas LINDA se han empleado en numerosos ámbitos con gran éxito. Sin ir más lejos, no hace demasiado descubrí un proyecto que estaba empleando un sistema LINDA para crear un sistema de alto rendimiento de correo electrónico: los correos eran posteados en un sistema LINDA y un gran número de servidores podían acceder a él y llevárselos o tratarlos.

Manos a la obra Comencemos. Lo primero que tenemos que hacer es instalar una implementación de LINDA. Vamos a emplear la de Andrew Wilkinson, de la Universidad de York (Reino Unido), ver Recurso [1]. Tenemos que descargar la librería PyLinda 0.6 de la página que aparece en el Recurso [2]. Aunque en la página principal hablen de la versión 0.5, la última es la 9.6, ¡deberían actualizar la página! Muy bien, hay que descomprimir la librería, entrar el directorio resultante y ejecutar como root: # cd linda-0.6 # python setup install

Con este paso, y el nuevo y mejorado sistema de paquetes de python, habremos instalado la librería en nuestro sistema.

Primera prueba Siguiendo el tutorial que aparece en la misma página, lo que primero debemos hacer es arrancar el servidor de LINDA. Este programa creará una pizarra para que otros programas puedan trabajar sobre ella: # linda_server >

Listado 1: Servidor de sumas 01 import linda 02 03 linda.connect() 04 05 while(1): 06 datos = linda.universe._in((“suma”,int ,int)) 07 linda.universe._out((“resultad o”,datos[1]+datos[2]))

42

Número 27

De acuerdo, ya tenemos pizarra, hagamos ahora algo simple. Vamos a conectarnos a ella y a poner un «trabajo». Este trabajo no será más que una lista de Python con 3 números, que ejecutamos desde Python: >>> import linda >>> linda.connect() True >>> linda.universe._outU ((1,2,3,4)) >>> linda.universe._outU ((5,6,7,8)) >>>

Hemos puesto una lista en la pizarra y debemos salir de nuestro script Python. Podemos comprobar en linda_server lo que acabamos de hacer: > help Possible commands... list - Print list of allU tuplespaces on the serverU inspect - List theU tuples in the given tuplespaceU watch -U Repeat the given commandU every seconds.U If left out defaultsU to 10. quit - Shut down the server. > > list TupleSpaces: 0:0 > inspect 0:0 References: [] Blocked: {} Tuples: (1, 2, 3, 4) (5, 6, 7, 8) >

El servidor ha registrado nuestra lista en el TupleSpace 0:0. Arranquemos ahora otro

Listado 2: Cliente de sumas 01 import linda 02 linda.connect() 03 04 linda.universe._out((“suma”,78 571,2268)) 05 resultado = linda.universe._in((“resultado ”,int)) 06 07 print “El resultado es “,resultado

WWW.LINUX- MAGAZINE.ES

intérprete Python y recuperemos esa información: >>> import linda >>> linda.connect() True >>> linda.universe._inU ((int,int,int,int)) (1, 2, 3, 4) >>>

Con el método _in() y un patrón de lo que andamos buscando (decimos que queremos una lista con cuatro números enteros), LINDA nos devuelve aquello que encaje con lo que busquemos. Y por cierto, nos devuelve lo primero que encaje. Si hubiese más listas de las mismas características nos devolvería la primera, la «borraría» de la pizarra y dejaría el resto allí. Volvemos a nuestro servidor linda_server para ver lo que ha pasado: > list TupleSpaces: 0:0 > inspect 0:0 References: [] Blocked: {} Tuples: (5, 6, 7, 8) >

Efectivamente, LINDA ha devuelto la primera lista de cuatro enteros que ha encontrado y nos ha dejado en su sitio a la otra.

Patrones LINDA se basa en la técnica de reconocimiento de patrones. Hemos visto cómo nos devolvía una lista de 4 enteros si se la pedíamos, y tenía una. Pero este sistema es muy burdo. Veamos algo más interesante. Supongamos que el servidor de LINDA se está ejecutando: >>> import linda >>> linda.connect() >>> linda.universe._outU ((“Linux Magazine”,U “Jugando con LINDA”)) >>> linda.universe._inU ((“Linux Magazine”, str)) (“Linux Magazine”,U “Jugando con LINDA”) >>>

¿Qué ha pasado aquí? Hemos introducido en LINDA una tupla con dos cadenas, y después hemos pedido una tupla

DESARROLLO • Python

El resultado esU (‘resultado’, 80839) >

Un ejemplo práctico

Figura 1: Esquema de funcionamiento.

con una de las cadenas y el tipo str que vale como comodín para cualquier cadena. Como resultado, LINDA nos ha devuelto aquello que coincide con nuestro patrón. Los patrones no sólo pueden ser tipos de datos, ¡pueden ser datos en sí! Es ahora cuando LINDA muestra su poder, porque podemos hacer lo siguiente:

programas que pongan operaciones en LINDA y programas que las resuelvan, ¡dejando el resultado! Podemos dejar tuplas como: ([“suma”,9],”ejecutar”, 23, 88)

Y recoger tuplas como: ([“suma”,9],”resultado”, 101)

>>> linda.universe._outU ((“suma”,2,3)) >>> linda.universe._inU ((“suma”,int,int)) (“suma”,2,3) >>>

¿Puede adivinar a imaginar las posibilidades de este sistema? Podemos crear

Listado 3: Cliente que manda información 01 02 03 04 05 06 07 08 09 10 11

import linda import socket import time linda.connect() host = socket.gethostname() while (1) : hora = time.asctime()

linda.universe._out((host,hora )) 12 time.sleep(30)

44

Número 27

Que vendrían a significar: soy el programa 9 y dejo aquí una suma para que alguien la ejecute. El resultado sería: soy la suma que dejó el programa 9 y aquí está el resultado que alguien ha calculado. Veamos dos programas que hacen exactamente eso, ver Listado [1] y Listado [2]. Al arrancar el servidor y el cliente el resultado es, en el lado del cliente: > python2.5U cliente-sumador.py

Listado 4: Servidor que imprime la información 01 import linda 02 03 linda.connect() 04 05 while(1): 06 datos = linda.universe._in((str,str)) 07 print datos[0],” => “, datos[1]

WWW.LINUX- MAGAZINE.ES

Supongamos que tenemos más de un ordenador en una red y que queremos recibir información sobre el estado de estos ordenadores. Existen muchos mecanismos que nos permiten hacer esto. Sin ir más lejos me vienen a la cabeza Nagios (ver Recurso [3]) o Zabbix (ver Recurso [4]). Nosotros vamos a crear algo más simple. Haremos que las máquinas cliente actualicen su estado en un servidor que estará ejecutando el servidor linda_server. Para ello, las máquinas cliente dejarán una tupla que informará de su IP y de la carga del sistema. Como podemos ver en el Listado [3], los clientes recogen la información y la “inyectan” en LINDA. En el Listado [4] aparece el código del recolector, que se dedica a mostrar por pantalla la información mostrada por los clientes. Debemos arrancar nuestro servidor linda_server y después arrancar el programa del Listado [4] en la máquina que actuará de vigía, y el programa del Listado [3] en las máquinas que queramos controlar. ¿Es poco código? Es lo que ocurre cuando usas una buena idea y Python ;)

Conclusión LINDA es tan sencillo que incluso los ejemplos parecen triviales, pero no debemos olvidar la cantidad de trabajo y la complejidad de crear un sistema distribuido de cualquier tipo empleando las técnicas tradicionales. IBM y otras empresas disponen de implementaciones industriales (y cerradas) de LINDA, pero Py-Linda no se queda corta y permite crear sistemas más o menos eficientes. De hecho, el proyecto SETI@home emplea una técnica parecida a LINDA. A veces, las técnicas del pasado revo■ lucionarán el mañana.

RECURSOS [1] http://www-users.cs.york.ac.uk/~aw/ pylinda/index.html [2] http://www-users.cs.york.ac.uk/~aw/ pylinda/dist/linda-0.6.tar.gz [3] http://www.zabbix.org [4] http://www.nagios.org