Angel "Java" Lopez : Inteligencia Artificial

Bing, el nuevo chico del barrio

lopez — Sat, 30 May 2009 09:39:00 GMT

Llegó el nuevo producto de Microsoft, que presentan, no como un buscador, como un engine de búsqueda, sino como un motor de decisiones:

http://www.decisionengine.com

(Please visit the site to view this media)

Como empresa gigante, Microsoft se puede dar el lujo de tener un gran equipo de research, y llega el momento en que todo ese conocimiento y esfuerzo se vuelca en algún producto (no siempre).

Yo todavía tengo que probar ese producto, que no está liberado al público. Como muchos productos globales, hoy se anuncian de esta manera, con un video viral, como el de arriba, que no sólo está en el sitio, sino que también está en Youtube, y lo puedo embeber en mis blogs.

A simple vista, es un producto que montado sobre ideas (no implementaciones) de web semántica, apunta a no tener tanto agentes recorriendo y obteniendo información, sino a presentarla y organizarla para que el usuario tenga una experiencia distinta.

Veremos si cumple con la expectativa. Pero es interesante ver cómo la fuente de la información es la propia web. También es interesante notar que la información de la que parte, no estaba pensada para ser consumida de esa forma. Eso es lo que imagino que va a pasar con las ideas de web semántica. Las páginas publicada sólo va a comenzar a contener información semántica, cuando este tipo de aplicaciones se popularicen. Mientras tanto, el “trabajo sucio” de obtener información de los datos de una página, quedará a cargo de las aplicaciones.

No veo que sea una “killer application” para Google. Más bien, como Wikipedia, va a brindar otra experiencia de usuario. Así como hay temas que investigamos con Google, así como habrá otros más estructurados que investigamos partiendo de Wikipedia, habrá consultas, tareas, comparaciones, donde preferiremos (o no) a Bing.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Computadoras aprendiendo música

lopez — Mon, 18 May 2009 04:25:00 GMT

Gracias a un tweet de @maraoz, me enteré que estaba MatBaires 09, Festival Matemático, el fin de semana pasado, en el Centro Cultural Recoleta, acá en Buenos Aires. Me perdí varias conferencias (el bueno de @maraoz envió el mensaje el sábado), así que no pude asistir a ver a Gregory Chaitin, Guillermo Martinez, y a otros, como John Allen Paulos. Pueden ver el programa y los temas en:

http://www.festivalmatematica.gov.ar/home09/web/es/index.html

(recuerdo haber trabajado en los ochentas, con el intérprete Lisp que Chaitin había escrito en Fortran, en la Universidad de Buenos Aires, yo fui lo bastante nerd como para reimplementarlo en assembler de 8080…. ;-)

Una charla a la que pude asistir fue:

¿Puede una computadora aprender a componer música?

Por Pablo Rodríguez Zivic.

Al escuchar una pieza musical, uno es capaz de extraer información acerca del estilo, la métrica, y tal vez teniendo mayor conocimiento sobre teoría musical, cuestiones relacionadas con la armonía y el contrapunto. Todo músico es influenciado por otros músicos debido a diferentes razones, y esta capacidad de ser influenciado está estrechamente relacionada con la capacidad de extraer información útil para la composición a partir de escuchar lo que otros ya han hecho. Ahora, la pregunta es: ¿es posible darle a una computadora un conjunto de piezas musicales y que esta sea “influenciada” por este conjunto para componer nueva música?

(ver la actividad del domingo 10 de Mayo en http://www.festivalmatematica.gov.ar/home09/web/es/events/index/v/date/20090510.html#)

Pablo está trabajando en Popego, que yo sepa, y es compañero entonces de @santisiri y @scoffey, los que conocí personalmente ahí, entre el público. Popego está aplicando técnicas de inteligencia artificial, creo que son los de Zauber quienes las programan… Pero vayamos al tema de la conferencia.

Pablo se manejó bien, hubo bastante asistencia, y comenzó a tiempo. Excelente sonido, que fue aprovechado por Pablo para presentar el trabajo que está realizando para su tesis, comenzado hace apenas unos meses.

Primero planteó qué es una computadora, qué es aprender y qué es componer música.

A la primera pregunta, presentó que una computadora es un programa. Remontó todo al cálculo lambda (si, como gran parte de la humanidad, NO ESTAN suigiendo mis posts, lean:

Notas sobre el Cálculo Lambda
Presenting AjLambda, lambda calculus in C#
Presentando AjLambda: implementación de Cálculo Lambda en C#

)

Pablo hasta usa la misma foto de Alonzo Crurch que uso en mis charlas… :-)…. y luego comentó su equivalencia con las máquinas de Turing.

Con respecto a aprender, no me quedó tan claro hacia adonde apuntaba en su charla. Yo colecciono enlaces sobre Machine Learning en

http://delicious.com/ajlopez/machinelearning

Y despues comentó sobre qué es componer música. Y destacó que lo que uno considera música, depende de nuestro criterio humano. De ahí el desafío para un programa: que produzca no ruido, sino música.

En ese tema, recordó el trabajo de Heinrich Schenker. Pueden leer sobre su trabajo

Schenkerian analysis - Wikipedia, the free encyclopedia
Tom Pankhurst's Guide to Schenkerian Analysis - Home Page.
Schenker Analysis for Pantonal Composition

Pablo comentó que si bien Schenker describía sus ideas sobre cómo analizar música, no daba pautas claras, lo que hoy llamaríamos un algoritmo. Recordó el trabajo de Fred Lerdahl y Ray Jackendoff:

Amazon.com: A Generative Theory of Tonal Music: Fred Lerdahl, Ray Jackendoff...

Por lo que entendí, estos trabajos se basan en gramáticas generativas (yo diría a al Chomsky), para ir describiendo música. Pablo presentó una partitura analizada de esa forma.

Y luego llegaron los platos fuertes, el trabajo de Pablo en acción.

Presentó en su notebook, un programa que lee y ejecuta un archivo MIDI y luego lo modifica, agregando notas (en un instrumento elegido manualmente), especificando altura y duración, SOBRE la música original. Ejecutó tres pruebas, recuerdo una sobre Mozart, y otra sobre Gershwin. Muy bien logrado la salida del programa, que no digamos “uy que bruto, que música generada….” ;-) pero era aceptable como producción.

Para cada música, presentó un diagrama de las decisiones que tomaba el programa para elegir su próxima nota. Pero no aclaró mucho sobre cómo se formaba ese diagrama. No parecía que tuviera relación con gramáticas generativas.

Al final, hubo una animada sesión de preguntas, lo que revela el interés que había despertado en el público. Yo pregunté si podía explicar en detalle el algoritmo que había usado para su programa, pero respondió que nos dormiríamos. Ahí se reveló que gran parte de la audiencia conocía de algunos temas, y luego de algunas preguntas más, Pablo soltó la prenda: estaba usando cadenas de Markov.

Eso era algo distinto de la línea que venía explicando. Recuerdo haber leido artículos sobre generación de música usando

Alguien preguntó sobre si se podía aplicar este “approach” a literatura. Me hubiera gustado comentar ahí dos cosas: una, recordar a mi apreciado Stanislav Lem, que en uno de sus excelentes “prólogos inventados”, creo que de su libro “Vacío perfecto”, trata de supercompadoras militares, una de las cuales se dedica en algún tiempo libre a analizar la obra de Dostoievsky, descubriendo que sus escritos forman una especie de toro en varias dimensiones, a las que le falta un pedazo. Y lo completa, escribiendo una obra que falta, a la que Lem describe con detalle, y uno se convence de que es la obra que Dostoievsky debería haber escrito.

Otra: que hay trabajos sobre la generación de texto, usando gramáticas generativas. Yo recordaría mi post:

Posmopolitan

Hubo varias sugerencias sobre cómo podría seguir Pablo con su trabajo. Creo que quedó la impresión que las cadenas de Markov son un “dead end”, pero habrá que ver.

Si hasta estuvo Gregory Chaitin y todo preguntando!!! (la primera vez que lo veo en persona!!)

Yo recuerdo haber sugerido:

- Armar un sistema que emplee reglas generativas, pero que las reglas se vayan descubriendo o aprendiendo (no tener que escribir las reglas). Yo me imagino un trabajo como el de Lenat con Eurisko, se le dan al programa música, y va intentando descubrir por sí mismo reglas

- Tener en Internet un comparador de música generada, para que los seres humanos vayamos “taggeando”, “rankeando” nuestras preferidas. Una especie de popego de música generada… ;-)

Y en algún momento, haría hincapié en el tema de “aprender”. Ese es un camino difícil, pero que puede ser fructífero. Que el programa se modifique a sí mismo, a sus reglas, a sus decisiones, lo que sea, pero que el programa evolucione.

Comentaría acá algo adicional: exploraría en algún momento, el jazz. En esa música, se encuentra la tensión entre lo que el oyente espera, y lo que ejecutante decide. Si lo que el ejecutante es demasiado aleatorio, se pierde el encanto. Si es demasiado predecible, no hay gracia. O tal vez, comenzaría por Bach, y hacer que el programa haga ingeniería inversa, redescubra reglas de la fuga. Se comentó algo

Si quieren ver algo sobre cadenas de Markov en música, a visitar:

michael clemow " Blog Archive " markov chain music
CiteULike: Extracting Patterns in Music for Composition via Markov Chains
Digital Music Programming II- Markov Chains

En el medio de las preguntas, Pablo mencionó al pasar otros temas: me temo que los mencionó al pasar (uno de los pocos defectos de la charla, mencionar algo sin dar un detalle más firme sobre lo que avanzar). Supongo que eran:

CiteULike- The nested Chinese restaurant process and hierarchical
GWCR - Generalized Weighted Chinese Restaurant Monte Carlo algorithm
Dirichlet process - Wikipedia, the free encyclopedia

De nuevo, supongo que está explorando formas aplicar análisis estadístico sobre música de entrada. Recuerdo varios artículos que tengo en otro cubil, sobre la aplicación de cadenas de markov, y otros, sobre cómo se obtenían distintas reglas, según la entrada sea mucho blues, vs música más “clásica”. Hubo un tiempo en los ochentas, que Douglas Hofstadter se ocupó mucho del tema. Debo tener alguna Scientific American son eso.

No recuerdo que Pablo haya mencionado a Eugene Narmour, parece que lo mencionó en una charla que tuvo con Chaitin luego. Ver:

Eugene Narmour

Algunos enlaces que voy coleccionando sobre el tema

http://delicious.com/ajlopez/computermusic

Pablo abrió hace unos días, su blog, para los que quieran seguir su progreso:

http://lacompositora.blogspot.com/

Pueden leer ahí su avance sobre la línea Narmour.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
http://ajlopez.popego.com

Enjoying Pappo playing piano, third video at Más blues con Pappo
No algorithm for that music, yet! ;-)

Modelo, decisiones, inteligencia artificial y AjGenesis

lopez — Sun, 22 Mar 2009 20:28:16 GMT

En el recientemente creado grupo de Google AltNet-Argentina, el bueno de Fabio Maulo planteó una pregunta en el thead:

ORuM

donde escribía

Quien me conoce un poco, o me ha leido en algún lado, conoce ya la acronimo
ORuM.La realida es que nunca tuve la ocasión de una buena confrontación
sobre el tema.
Para titular la mesa sería:
Object Relational unMapping
Mas allá del ORM.

Quisiera compartir, confrontar, ampliar algunas ideas y verificar la
factibilidad.

La idea es tener en claro, cómo se toman algunas decisiones, en el caso de tener un dominio de clases, y llegar al mapeo de en una base de datos, no preexistente. Es un caso tipo, como escribía el propio Maulo:

Yo quisiera llegar a : "che, yo tengo este dominio que tendría que persistir en ORACLE, fijate vos! a mi lo que me interesa es que persista."
El DSL sería:
Che.Tengo("MiDominio.dll").Que.TieneQuePersistirEn("ORACLE").FijateVos();

Para mí, esto es parecido a lo que trato muchas veces de resolver con AjGenesis:

"Tengo X quiero resolverlo con Y", donde X puede ser un dominio de entidades, un dominio más tipo DDD, una lista de servicios, lo que sea, e Y sería JSP, Struts2, JSF, ASP.NET MVC, NHibernate, Hibernate, MySql, SQL Server, y demás. Es lo mismo que hace un programador: toma decisiones, ante lo que tiene que hacer.

Es por eso que en AjGenesis tomé algunas decisiones tempranas, para poder ir avanzando en un camino, que menciono en:

Sobre la generación de código

... el modelo a usar ... PUEDE SER GENERADO por el propio sistema, más un sistema experto. No imagino una aplicación más inmediata de la "inteligencia artificial". Imagino agentes inteligentes, que colaboren en una red compartida, cada uno generando parte del modelo, cada uno consumiendo algo que otro produce, y colaborando, para generar un sistema... Sí, ya sé, tengo que tomar la píldora verde, en lugar de la roja... ;-)

Esa es una de las razones de tener en AjGenesis:

- un modelo
- más que sólo un lenguaje de templates
- aplicar el lenguaje en tasks, que modifican y completan el modelo

Si sólo tuviera templates, sólo haría transformaciones X -> Z, de una forma, digamos, lineal, desde, para poner un ejemplo, una clase o un modelo que describe una clase, a un código o archivo de configuración de persistencia.

A lo que voy, es que el camino que quiero para AjGenesis, en algún momento (no para que todos lo usen así), es que sea un sistema experto, que tome decisiones. De ahí que, desde el principio:

- tenga un lenguaje completo, con toma de decisiones, que pueden ser complejas
- tiene acceso al framework de .NET, para poder ser extendido de cualquier manera.
- invoque a tareas, no simplemente a transformar el modelo X usando el template T

Eso explica también, algunos caminos que estoy explorando, como AjLisp, y AjProlog (aunque son más para entrenarme, que para aplicarlos directamente en AjGenesis). Habrá que investigar si este camino es posible, pero me parece que está relacionado con el tema planteado en el grupo. Veamos, volvamos al problema inicial.

De clases a persistencia

Las opciones de mapeo que podemos considerar, son las mostradas por el bueno de Martin Fowler:

Single Table Inheritance

Class Table Inheritance

Concrete Table Inheritance

En una situación ideal (no costo en tiempo de queries o de update, sin limite de memoria en disco), todo seria igual.

Como la situación no es ideal, me imagino que los costos de cada decisión se mediran en:

- Rendimiento de actualización y consulta

- Espacio de almacenamiento

A primera vista, me imagino que el primer punto es el mas peliagudo.

Para concretar, tomemos un modelo sencillo. Sea clase Empresa, subclases Cliente, Proveedor.

Habría que ver qué consecuencias tiene entonces, el tener una tabla empresas, con un campo discriminador de si es cliente o proveedor. ¿Qué pasa si hay muchos campos en comun? ¿O si hay muchos campos de diferencia? Pienso que mas va a influir el tema: ¿pero queda ahí el dominio? Si el día de mañana aparecen más subclases, ClienteExtranjero, ProveedorExterno, ¿no se complicará el haber adoptado una sola tabla?

Si ponemos tablas Empresa (con los datos comunes), Clientes (con los datos adicionales), Proveedor (con los datos adicionales), habrá que hilar fino en las consultas. No sólo está el tema del rendimiento de actualización y consulta. Tambien esta la frecuencia de algunas operaciones. Es decir, si una consulta determinada tarda X tiempo, habrá que ponderarla tambien por la frecuencia de esa consulta en la operación normal del sistema.

Con tablas Clientes, Proveedores, habra que comprobar que la actualizacion sea mas rapida que en el anterior caso. Y vigilar que pasa, y con cuanta frecuencia, se necesita una consulta sobre Empresas (que imagino debera implicar un UNION).

Entonces, no sólo es el modelo de clases, sino cómo se usa, lo que puede influir en cómo hagamos el mapeo.

ESTO ES LO QUE YO VEO EN MUCHOS MODELOS ya existentes, que no tienen todo LO QUE SE NECESITA DE UN MODELO. Un modelo de clases se queda corto, para tomar algunas decisiones. Lo mismo, si partimos desde una base ya diseñada. Partir de esos modelos, implica que en algún momento lo tenemos que enriquecer, con anotaciones en el modelo de clases, o agregando información en metadata o en algún momento, si partimos desde la base de datos.

Partir de un modelo de clases o de la base de datos, tiene la ventaja de partir de algo conocido. Pero para muchas de las operaciones que quisiéramos hacer (en este caso "simple", mapeo a relacional, imaginen otros casos como servicios distribuidos, seguridad, cache en el cliente, etc.), hace falta más información de contexto.

De ahí, que yo esté a favor de un modelo distinto, más enriquecido.

De Aristóteles a Kant

En los noventa, en una revista Byte, leí una breve reseña, sobre gente que estaba armando algo que lo llamaban KANT. En honor a las categorías del filósofo alemán (yo diría que se referían más a categorías de Aristóteles), ellos planteaban que todo en, lo que hoy llamaríamos, modelo, está incluído en alguna categoría como:

- Persona
- Organización
- Bien Físico
- Lugar Físico
- Documento
- Suceso
- Lapso

y demás. Por ejemplo, un Empleado entraría en la categoría Persona, un Cliente o Proveedor, en la categoría Organización. El que un Empleado estuviera contratado por una Empresa, era un Lapso (un intervalo, posiblemente abierto, de tiempo) establecido entre una Persona y una Organización. A partir de las categorías, se podía inferir que toda Persona tiene fecha de nacimiento, y otros atributos, que un Lapso puede tener tiempo de inicio y tiempo de final. (Escribo sin tener la referencia, de memoria).

Esa reseña siempre influyó en lo que quiero hacer con un modelo rico, abstracto. Sirve para poner más semántica sobre lo que estamos describiendo, más de lo que daría un modelo de código o de base de datos. Sigo pensando que algo así debe ser el modelo del que partir, en la generación de código o en otras ideas.

Apenas una punta de eso (el tener categorías llamadas prototipos, que sirvan de base para generar un modelo simple), está desde hace tiempo en AjExamplesExamples3.zip, en el directorio Prototypes, y Seeds. Es una idea con implementación mínima, a explicar en detalle en otro post.

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/
http://twitter.com/ajlopez
En estos días, revival de los 80s en mi vida http://www.youtube.com/watch?v=dgwmErO_nlQ

Material y enlaces de Inteligencia Artificial

lopez — Mon, 09 Feb 2009 08:21:23 GMT

El pasado miércoles tuve el gusto de dar una charla sobre Inteligencia Artificial, organizada por el Club de Programadores. Quería presentar en este post el material usado, ejemplos, enlaces mencionados, recursos y bibliografía que recomendé.

El campo de la Inteligencia Artificial es inmenso, y con el correr de los años se ha ido abriendo en ramas distintas, que a veces, poco tienen que ver unas con otras.

La presentación que usé la pueden bajar de IntroIA2009012003b.ppt. Una presentación más antigua, pero más completa (de un curso de dos días) en: IntroIA200501.zip.

Se está formando un grupo de gente interesada en la Inteligencia Artificial, acá en Argentina, leer:

Inteligencia Artificial en Argentina

Mencioné que este año hay un congreso de Inteligencia Computacional Aplicada, leer

Congreso de Inteligencia Computacional Aplicada

Para un primer pantallazo de las ramas, y algo de la historia, puede servir de base el artículo de la Wikipedia:

Artificial Intelligence
History of Artificial Intelligence

Un sitio a visitar es el de Peter Norvig:

Peter Norvig

Un paper totalmente recomendable, para leer las ideas de Marvin Minksy, sobre cómo podría funcionar una mente:

Future Models for Mind-Machines

Más discutible, desde mi punto de vista, son las ideas de Kurzweil, pueden visitar su sitio:

KurzweilAI.net

Mencioné en varios puntos de la charla, un paper que describía la historia de la Inteligencia Artificial, y cómo durante décadas, todos los intentos comerciales fueron fracansando:

If it works, It's not AI

Un artículo reciente, que tiene una visión más optimista:

Future Watch: A.I. comes of ages

Mencioné el trabajo de Douglas Lenat. Pueden ver lo que está haciendo ahora, persiguiendo el sentido común en:

http://www.cyc.com/

Sitios a visitar sobre Inteligencia Artificial:

http://www.aboutai.net About AI, enlaces sobre distintos temas de AI
http://www.pcai.com/ PC AI Free Magazine
http://www.jair.org/ Journal of Artificial Intelligence Research
http://www.aaai.org/ Association for the advance of Artificial Intelligence

Varias explicaciones de distintos temas, con ejemplos de codigo en

AI Junkie

Lenguajes de Programación

Mencioné en la charla algunos lenguajes. Tienen enlaces dedicados en:

Lisp donde los programas se pueden manipular como datos
Prolog dedicado a implementar programación declarativa

Al final del post, hay libros sobre distintos temas, donde se usan esos lenguajes (ver por ejemplo libros en la web).

Un ejemplo que tenía preparado, pero no mostré, se basaba en usar P#, una implementación de Prolog de código abierto.

Yo estoy trabajando en un intérprete Lisp, ver AjLisp- un intérprete Lisp en .NET.

Ver también

AI Programming (Lisp)
AI Programming (Prolog)

Lógica difusa

El ejemplo que usé en la charla (el de la grúa con contenedor controlado por lógica difusa) es de:

Fuzzy Tech http://www.fuzzytech.com

Sistemas basados en reglas

No vimos ejemplos en la charla, pero pueden visitar:

Jess sistema basado en reglas, en Java (basado en el algoritmo Rete).

Aprendizaje automático

Algunos enlaces

UCI Machine Learning Group
Machine Learning in Games
Machine Learning (AI on the Web)

Planeación

Nombramos los problemas de la planeación. Visitar:

What is Partial-Order Planning?
Review of An introduction to Least Commitment Planning
Selected History of Partial Order Planning, Part 1 (donde aparece Sacerdoti, mi primer referente en el tema)
Selected History of Partial Order Planning, Part 2

Redes Neuronales

En la charla vimos una demo del producto comercial:

NeuroSolutions

El ejemplo de hormigas controladas por redes neuronales que evolucionaban por algoritmos genéticos, en:

Neural Networks in plain English

Algunos enlaces adicionales:

http://www.inns.org/
http://www.nips.cc
http://www.makhfi.com/resources.htm
http://www.makhfi.com/realworld.htm
http://www.neoxi.com/NNR/index.html
http://www.ri.cmu.edu/pubs/pub_926.html
http://vasc.ri.cmu.edu/NNFaceDetector/
http://www.deepinsight.com/
http://satirist.org/learn-game/systems/neurochess.html
http://satirist.org/learn-game/systems/go-net.html
http://satirist.org/learn-game/systems/gammon/
http://www.20q.net/ Twenty Questions Neural-Net on the Web
http://gpdev.net/NeuroDriver_bpnet.html
http://www.codeproject.com/csharp/neural_dot_net.asp
http://www.codeproject.com/dotnet/simple_ocr.asp
http://www.codeproject.com/script/articles/list_articles.asp?userid=441940

Algoritmos Genéticos

Leer como introducción

Genetic Algorithms in plain English

Mostré mi ejemplo de:

AjGa- una librería de algoritmos genéticos

Otros enlaces:

Galib Librería de Algoritmos Genéticos http://lancet.mit.edu/ga/
http://delicious.com/ajlopez/geneticalgorithms

Enlaces adicionales

Genetic Algorithms and Genetic Programming (multitud de enlaces)
What is Genetic Algorithms?
Genetic Programming
Genetic Algorithms
Survival of the Fittest: Natural Selection with Windows Forms (en .NET)
An introduction to Genetic Algorithms In Java
AIAI Technology Genetic Algorithms
Genetic Algorithms and the Traveling Salesman Problem (en C++ para Windows)

Programación Evolutiva

Estuvimos viendo mi ejemplo

Jugando con programas evolutivos

Estuvimos corriendo el ejemplo de AI_Life, donde vimos redes neuronales, algoritmos genéticos y conductas de persecución.

Juegos e Inteligencia Artificial

Primero, el tema juegos de tablero.

En el proyecto Reversi pueden ver una implementación del algoritmo MinMax con Alfa Beta.

En Connect Four y en Learning Draughts pudimos ver algunas estrategias simples de aprendizaje.

Para tener un panorama de los problemas actuales, hay que visitar el grupo de la Universidad de Alberta:

http://www.cs.ualberta.ca/~games/

Pueden visitar el grupo de Research de Microsoft:

Applied Games

Pero también hay inteligencia artificial en juegos de video. Recomendaría visitar:

Game IA

What is BattleCode-

Artificial Intelligence and Computer Games

AI- AAAI Library online

Game AI for Developers — AiGameDev.com

El tema de máquinas de estado es muy usado, pueden leer

State-Driven Game Agent Design

Computer Go

Para mí, un tema fascinante. Vimos en la charla, a mi ejemplo AjGo:

AjGo- hacia un programa que juegue al go

Pueden visitar:

Computer Go in Microsoft

Hay otro grupo de investigación sobre el tema en Beijing:

Craking Go a cargo de Feng-hsiung Hsu

Mis enlaces sobre Computer Go en http://delicious.com/ajlopez/computergo

Todo sobre Go en http://www.gobase.org

Si quieren aprender el juego, pueden visitar el sitio de la Asociación Argentina de Go.

Vida Artificial

Un tema fascinante, nombrado al pasar en la charla. Visiten el proyecto Tierra

http://life.ou.edu/tierra/

Vean las "fotos" de:

http://life.ou.edu/pubs/images/

Otro proyecto que también investiga el tema evolución es:

Darwin at home el resultado de aplicar Fuidiom
Fluidiom Implementado en Java, sería interesante implementar algo similar en .NET y DirectX/OpenGL

Robótica

Mostré el ejemplo de:

Que lindo el guaguau- BigDog de Boston Dynamics

Más enlaces en:

Post sobre Robótica
http://delicious.com/ajlopez/robotics

GRASP Laboratory of Robotics Research and Education @ Penn
Microsoft Invisible Computing
Concious Robots
Robotics Studio at Concious Robots (con algún foro en español)
An introduction to Programming Robots with Microsoft Robotics Studio
Wimo: The Windows Mobile Robot

Bibliografía

Nils J. Nilsson escribió varios libros en estas últimas décadas. Yo recomendaría este libro para una primera aproximación, bastante completa, a la Inteligencia Artificial actual:

Artificial Intelligence: a new synthesis

En español, en Argentina, Librería Cúspide como Inteligencia Artificial: una nueva síntesis.

Uno de sus libros está en línea: How Are We To Know-

Uno de los libros que recomendé es el de Russell y Norvig (es muy bueno en las notas históricas al final de cada capítulo):

AI- A Modern Approach

Si están en Argentina, lo pueden encontrar en español, por ejemplo, en librería Cúspide, como Inteligencia Artificial un enfoque moderno.

Otro de Norvig es

Paradigms of AI Programming

Los interesados en lenguajes de programación e Inteligencia Artificial, pueden examinar el clásico de Bratko, muy bueno para aprender la relación entre programación declarativa e Inteligencia Artificial:

Prolog Programming for Artificial Intelligence

Varios libros gratuitos en línea sobre Inteligencia Artificial en

Free Artificial Intelligence Books (visiten el sitio, que hay todos temas, de computación, matemáticas y ciencia).

Enlaces adicionales

Desde hace unos años, mantengo en mi sitio

Enlaces sobre Inteligencia Artificial
Enlaces sobre Redes Neuronales
Enlaces sobre Computer Go

En los últimos tiempos, directamente agrego en mis enlaces de Delicious:

http://delicious.com/ajlopez/artificialintelligence

Los posts que escribo están bajo el tag:

Inteligencia Artificial

Espero que les sirva este material, para explorar tan fascinante tema.

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/
http://twitter.com/ajlopez

Charla de Inteligencia Artificial

lopez — Sun, 01 Feb 2009 22:08:02 GMT

Como saben, el tema de Inteligencia Artificial me entusiasma e interesa. Este siglo ya di tres charlas sobre el tema, es hora de volver sobre el amplio y diverso temario de lo que se ha dado a llamar históricamente IA.

Hoy, es un término que abarca disciplinas muy diferentes, con distintos temas como:

- Sistemas expertos
- Redes neuronales
- Algoritmos genéticos
- Programación evolutiva
- Lenguajes de programación
- Aplicaciones en juegos
- Robótica
- Algoritmos
- Vida artificial
- Agentes autónomos
- Mineria de datos

y como siempre, el tema de fondo: conseguir reproducir la inteligencia humana, que recién estamos comenzando a conocer. También existe el costado filosófico: ¿qué es inteligencia? ¿será posible crearla artificialmente?

Voy a tratar una introducción de varios de esos temas (no todos, que es demasiado), con conceptos y ejemplos, en la charla gratuita del próximo miércoles 4 de Febrero, desde las 18:30, en el Club de Programadores. Es gratuita, pero tienen que inscribirse:

Charla de Inteligencia Artificial

Espero que les interese. Algunos (demasiados) enlaces sobre el tema, en:

http://delicious.com/ajlopez/artificialintelligence
http://www.ajlopez.com/ia/

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/
http://twitter.com/ajlopez

AjGa: una librería de algoritmos genéticos

lopez — Wed, 28 Jan 2009 07:33:03 GMT

Estuve codificando una librería de algoritmos genéticos, usando C#. El código está en mi proyecto AjCodeKatas en Google Code dentro de:

http://code.google.com/p/ajcodekatas/source/browse/#svn/trunk/AjGa

El proyecto principal es AjGa (con AjGa.Tests para testing):

Las principales interfaces son:

Uso generics, con dos tipos genéricos: G, que es el tipo de implementación de un gen, y V como el tipo al que se evalúa un genoma (por ejemplo, int, double). Con ese valor se catalogan los genomas.

IPopulation es una colección de genomas.

IGenome es una colección de genes, que es evaluado a un valor de tipo V.

IEvaluator está a cargo de evaluar un genoma.

La implementación de IEvolution ejecuta generaciones sobre una población, que va cambiando, usando mutadores, operadores de cruzamiento, para irla modificando después de cada ejecución.

Hay interfaces para generar un genoma, mutar uno existente o hacer cruzamiento de dos genomas.

Para probar estas ideas, implementé un proyecto con gen, genoma, y operadores, que ataca el clásico problema del Travelling Salesman Problem, el vendedor que tiene que visitar una serie de ciudades, minimazando la distancia a recorrrer:

En este ejemplo, el evaluador tiene una lista de posiciones de ciudades a visitar:


    public class Evaluator : IEvaluator<int, int>
    {
        private List<Position> positions;

        public Evaluator(List<Position> positions)
        {
            this.positions = positions;
        }

El tipo de gen acá es int, y cada valor de genoma se expresa como un int. El genoma mantiene una lista de enteros, que representan el número ordinal de las ciudades a visitar:

    using AjGa;

    public class Genome : BaseGenome<int, int>
    {        
        public Genome(int size)
        {
            for (int k = 0; k < size; k++)
            {
                AddGene(k);
            }
        }

Esto es, cada gen es un int, y un genoma con genes 2, 0, 1, representa un viaje que visita la tercera ciudad, pasa por la primera, y termina en la segunda.

Podemos ejecutar el proyecto WinForm, para probar esta implementación:

En la ejecución de arriba, la distribución de ciudades es al azar. Las ciudades pueden ser distribuidas en una grilla:

De esta forma, podemos probar la eficiencia del algoritmo para encontrar un solución óptima, que en el caso de disponer las ciudades en grilla, se conoce de antemano.

Si queremos implementar un nuevo proyecto GA, tenemos que:

- Definir el tipo que tendrán los genes

- Definir el tipo valor a usar

- Escribir operadores (creadores, mutadores, cruzadores) de genomas

Los tests que tengo están en verde:

Buen Code coverage:

En 4 horas tuve la primera versión, gasté 3 horas explorando TSP, y cerca de 8 horas preparando y "tuneando" la aplicación WinForm.

Como de costumbre, ¡me divertí escribiendo este ejemplo!

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

UMan, un robot que aprende a usar herramientas

lopez — Wed, 07 Jan 2009 08:47:27 GMT

Me encontré con este artículo

A Robot That Learns to Use Tools

que describe al UMan, un robot desarrollado en

Robotics and Biology Labs

de la Universidad de Massachusets. Me gustó mucho el camino que eligieron: el robot va interactuando con el entorno, y va aprendiendo a manipular los objetos que encuentra, deduciendo sus relaciones.

Visiten la página del proyecto

http://robotics.cs.umass.edu/?n=Main.AMM

Ahí pueden ver estos dos videos

IP1.wmv
IP2.wmv

donde va explorando una tijera sobre una mesa, sin conocerla de antemano. Siempre es interesante encontrar este tipo de aplicaciones de aprendizaje. En lugar de tener que codificar laboriosamente su conducta, mediante software precargado, el agente puede aprender del entorno, e ir mejorando su interacción. Me parece un campo fascinante para explorar, donde la inteligencia artificial puede dar una gran ayuda en el desarrollo de este tipo de agentes corporizados autónomos.

Leo ahí sobre Autonomous Mobile Manipulation:

Autonomous Mobile Manipulation could be considered the holy grail of robotics: a successful approach to autonomous mobile manipulation has to integrate virtually every aspect of robotics, including mechanism and sensor design, low-level control, motion planning, machine learning, computer vision, and reasoning. Currently, most of the available robotic applications are either capable of performing a very limited set of skills, or can only operate in relatively structured environment. The task of bringing robots to houses and to our daily life remains a challenge. The commercial potential is promising. Truly autonomous robots could dramatically affect health care and planetary exploration. Moreover, those robots could contribute to logistic and military applications, maintain satellites in orbit, and many other tasks currently performed by humans.

Hay varios "papers" interesantes para leer en la página del laboratorio y del proyecto, por ejemplo, sobre elastics roadmaps. El más relacionado con este tema es

Dov Katz, Emily Horrell, Yuandong Yang, Brendan Burns, Thomas Buckley Anna Grishkan, Volodymyr Zhylkovskyy, Oliver Brock and Erik Learned-Miller. The UMass Mobile Manipulator UMan: An Experimental Platform for Autonomous Mobile Manipulation. In IEEE Workshop on Manipulation for Human Environments, Philadelphia, USA, August 2006.
Download as pdf

¡Excelente trabajo!

Más información, con otros proyectos, en:

Hot Robots

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/
http://twitter.com/ajlopez

Jugando con programas evolutivos

lopez — Tue, 16 Dec 2008 08:59:47 GMT

El fin de semanas, estuve escribiendo un ejercicio casi tipo codekata. Me gusta explorar la idea de programas evolutivos (como agentes con programas incorporados que van evolucionando en ambientes simulados), así que puse manos a la obra, y creé una solución dedicada a experimentar con una ejemplo de prueba de concepto. Está escrito en C#, usando VS 2008, usando el soporte de test de la herramienta. He publicado el código dentro de mi Google code project ajcodekatas en:

http://code.google.com/p/ajcodekatas/source/browse/#svn/trunk/EvolveExample

La solución es EvolveExample:

(Si no tienen el soporte de test de VS, pueden remover el proyecto Evolve.Test).

Las clases principales residen en el proyecto de librería de clases Evolve :

Animal representa un agente. Tiene una lista de Instructions, que son generadas al azar. El animal habita un campo con comida. Su programa tiene instrucciones como Eat, Move East, North, West, South, o Predate (tomar energía/comida de otro animal que esté en la misma celda de la grilla). Cada instrucción tiene un costo: un punto de energía. Eat es una instrucción que toma 10 puntos de energía o menos, tomando comida de la celda actual. Predate toma 100 puntos de energía o menos, restándoselo a otro animal que esté en la misma celda.

Para ver el programa en acción, lanzar el proyecto winform Evolve.GUI, seleccionar la opción Evolve -> Run. Veremos:

El campo es una grilla (en este ejemplo, de 20x20). Cada celda tiene un nivel de comida (verde está llena, negro es vacía). A la derecha, una lista muestra los mejores animales y sus programas. Los animales son rankeados de acuerdo a su nivel de energía al final de cada ronda de simulación. El programa continúa con más simulaciones, usando nuevos campos. En cada nueva simulación, la población es ordenada por energía descendente, y los mejores son incluidos en la nueva simulación, los lugares vacantes son ocupados por mutaciones de esos mejores, y algunos animales son inyectados con programas aleatorios.

Durante una simulación, aparece información sobre el nivel de comida y el animal que mejor se desempaña, al pie de la ventana.

Con las opciones de menú Food y Population podemos establecer el nivel de comida y el número de animales, a usar al comienzo de cada simulación. Estos valores se usan recién la próxima vez que elijamos Evolve -> Run. La opción Evolve -> Stop puede ser usado para terminar una serie de simulaciones.

Próximos pasos

Este es un primer ejemplo, una prueba de concepto que sirva de base. Tengo algunas ideas, para explorar en futuras versiones:

- Tener un conjunto de instrucciones más interesantes, con condicionales, y que sea sensible al ambiente. Me gustaría añadir instrucciones como "Si hay comida en tal dirección, ir hacia allí". En vez de un programa lineal, podría armar un árbol de instrucciones, algo como un programa Lisp.

- Los valores de ejecución (tamaño del campo, nivel de comida, energía inicial para cada animal), deberían poder establecerse por un formulario, y leer y grabarse de archivos XML.

- Serializar los resultados y poblaciones en archivos XML

- Evolución en un cluster. Podría usar AjMessages, AjAgents, o MPI sobre unc luster HPC, para simular evolución en una grilla o cluster de máquinas.

Como es habitual, ¡me divertí escribiendo este código!

Angel "Java" Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez
http://delicious.com/ajlopez

Inteligencia Artificial en Argentina

lopez — Fri, 12 Dec 2008 10:01:52 GMT

Hace un tiempo, postée sobre la reunión que tuvimos en Buenos Aires, sobre Inteligencia Artificial. Se comentó también en los foros de ADVA (Asociación de Desarrolladores de Videojuegos de Argentina), pueden ver el thread completo en:

http://adva.com.ar/foro/index.php?topic=5254.0

(más sobre la reunión en
Inteligencia Artifical en Buenos Aires
Artificial Intelligence meeting in Buenos Aires
)

Hay muchos puntos interesante, pero me gustaría publicar acá el fragmento de un mensaje de Hernán Moraldo:

Creo que la IA está en este momento en un punto crítico, en diferentes sentidos en el mundo y en Argentina. En el mundo, porque lo que hasta ahora era casi un juguete académico, al menos para el que miraba de afuera y excepto por algunos usos específicos, se convirtió en muy poco tiempo en una disciplina que invade todas las áreas de la tecnología, con usos muy cotidianos (a veces hasta invisibles), como en las cámaras con detección de sonrisas, los buscadores que son lisa y llánamente grandes estructuras de IA, la detección de voz en servicios telefónicos, los captchas, los filtros de spam, las interfaces basadas en gestos o en visión, y un larguísimo etcétera. Y no sólo estos usos cotidianos, por supuesto, ya que en general las más grandes formas de IA están pagas por grandes empresas u organismos de tipo militar por ejemplo.

En Argentina, porque está empezando a hacerse visible alguna actividad, y porque si se la sabe buscar hay demanda para las aplicaciones útiles de IA, entonces quienes se meten en esto en general llegan a sacarle el jugo. Creo que lo que hace falta es de alguna manera que la gente que viene trabajando en IA, de todos los sectores (privado, académico, amateur, etc) entre en comunicación para que no tenga que estar cada uno en la suya sino que se pueda compartir información, materiales, posibilidades de trabajo, etc. Pienso que aún una muy pequeña comunidad de IA local podría ser muy útil para todos los interesados en el tema acá.

Coincido con el comentario. Otro participante dió un panorama de la actividad de IA en el ámbito académico:

La comunidad local de IA no es pequeña y existe hace rato. Nosotros en la Universidad N. del Sur hacemos Inteligencia Artificial hace mas de 15 años. La Universidad del Comahue y la Universidad de San Luis también tienen grupos de IA, con diversos desarrollos, y nos conocemos todos entre si, tenemos muchos amigos y hemos hecho muchas cosas juntos. En la UN de la Patagonia también se desarrolla en IA. En la Universidad Nacional de San Juan y en la UN de La Pampa también. Ya mencionaron en la reunión a la UNCPBA. Todos con mayor o menor medida hacen algún desarrollo en IA. Todos tenemos contacto entre nosotros y con muchas universidades extranjeras con algunos convenios de cooperación internacional. El CACIC (Congreso Argentino de Ciencias de la Computación), que se hace todos los años en diferentes lugares del país (2009 en Jujuy), tiene hace mas de diez años un Workshop de Agentes y Sistemas Inteligentes (WASI), donde nos encontramos anualmente varios investigadores de éstas y otras universidades. Ocurre lo mismo con las JAIIO, que es menos itinerante que el CACIC, pero en el 2009 se hace en Mar Del Plata. Realizó varias veces un simposio Argentino de IA (ASAI) donde también reunían investigadores locales en IA.

La comunidad es grande, pero a veces no trasciende en el mundo empresarial.

Coincido con ambos comentarios. Uno de los asistentes a la reunión presencial, ya había comentado la separación que hay entre el mundo académico y la industria local. Nos faltaría un panorama de la industria, de las empresas que necesitan IA, que ya la están usando, o que están creando software con IA incorporada.

Pueden ver más información sobre el CACIC en Congreso Argentino de Ciencias de la Computación de este año.

Agregaría también el WICC 2008 (X Workshop de Investigadores en Ciencias de la Computación 2008)

Recuerden que el año que viene (2009) tenemos el

Congreso de Inteligencia Computacional Aplicada

acá en Buenos Aires.

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/
http://twitter.com/ajlopez

La inteligencia artificial y yo

lopez — Mon, 08 Dec 2008 15:24:19 GMT

Hace unas semanas, tuvo lugar una reunión en Buenos Aires, de gente interesada en el tema de Inteligencia Artificial. La idea de la reunión nació de un "twit" de @hhm (Hernán Moraldo) . Pueden leer:

Inteligencia Artifical en Buenos Aires
Artificial Intelligence meeting in Buenos Aires

Hasta aparecimos en

Game AI Roundup Week #48 2008- AiGameDev.com

Como "outcome" de la reunión, se armó una lista de correo, en Google Groups:

IA Grupo

Pueden ver que hay interesantes discusiones, y participantes de diversos ámbitos: programación de juegos, IA académica, robótica, estudiantes, e interesados como yo. Uno de los "threads" es de presentación de cada participante. Como blogger compulsivo, quisiera escribir sobre mi relación, mis motivaciones para interesarme en la Inteligencia Artificial.

Inicios

Como muchos de mi generación, mi primer contacto con algo relacionado con el tema de IA fue a través de la ciencia ficción. El bueno de Asimov, sus robots, sus tres leyes de la robótica, fueron lecturas de mi adolescencia. Cuando comencé a aprender qué eso del software y la computación, vi que realmente existía una amplia rama (con varias variantes) de la ciencia de la computación, bautizada en sus comienzos (confesémoslo, con algo de pomposo optimismo) Inteligencia Artificial.

Al ingresar a la Universidad de Buenos Aires, en 1980, comienzo a estudiar más seriamente sobre el tema. Comienzo a conocer los perceptrones del malogrado Rosenblatt, la crítica de Minsky y Papert, el auge de los sistemas expertos (recuerdo Mycin, y el trabajo de Feingenbaum), los lenguajes que se pueden automodificar, como Lisp y Prolog (recuerdo algún artículo seminal del Scientific American, y cómo me impresionó que ambos lenguajes tuvieran dialectos diferentes). Me impactó profundamente el trabajo de Douglas Lenat, con su AM y luego Eurisko: me parece, aún hoy, el programa más logrado. Lástima que Lenat abandonara ese trabajo y se dedicara a su proyecto Cyc. Ya varios de esos trabajos parecen lejanos o anticuados. Igual, pienso que es interesante estudiar la historia de la IA, porque enseña los problemas que se encontraron, los triunfos y fracasos, especialmente estos últimos, que dieron lugar al invierno de la IA.

Para los que no conocieron Eurisko, recomendaría:

Eurisko, The Computer With A Mind Of Its Own
Invention and Exploration in Discovery una reimplementación llamada Cyrano de las ideas de Eurisko

Quisiera recordar acá las excelentes lecciones del Ing. Guido Vasallo, que me guiaron en nuevos lenguajes y formas de programar, y al recientemente desaparecido Ing. Carranza, que siempre vestido de negro, y fumando en los descansos, nos enseñaba algunos temas de Inteligencia Artificial.

En aquellos años, armaba sistemas expertos de juguete, y algún intérprete Lisp. Sería largo de enumerar lo que luego vino, pero en resumen: siempre traté de agregar algo relacionado con Inteligencia Artificial, a mi trabajo de todos los días.

También en la UBA, conocí al juego milenario del go. Desde entonces, me interesó como ejemplo a estudiar, para programar IA que juegue aceptablemente.

Pasemos directamente a estos últimos años.

Enlaces, recursos y charlas

A principios de siglo, comencé a investigar de nuevo sobre Computer Go, e Inteligencia Artificial. En mi sitio, he ido coleccionando los enlaces que me interesaron, pueden visitar:

http://www.ajlopez.com/ia/

Luego, me convertí a Delicious, mis nuevos enlaces en:

http://delicious.com/ajlopez/artificialintelligence
http://delicious.com/ajlopez/artificiallife

En estos años, he estado dictando algunas charlas sobre IA, en el Microsoft User Group, el Club de Programadores y en algún TechNight de Microsoft, recuerdo:

Material de la Jornada de Introducción a la Inteligencia Artificial (MUG 2004)
Material del Seminario Introducción a la Inteligencia Artificial y .NET (Microsoft Argentina 2005)
Material del Seminario Introducción a la Inteligencia Artificial (Club de Programadores 2005)

Este año (2008) escribí sobre los temas que veo interesantes en IA:

Temas Interesantes de Desarrollo de Software, Parte 1- Inteligencia Artificial

donde encontraran enlaces sobre algoritmos genéticos, aprendizaje automático, planeación, vida artificial, juegos, lenguajes, visión por computadora, y robótica.

Computer Go

Dí una charla sobre Computer Go en el Congreso Argentino de Go de 2007 y de nuevo en el Congreso de este año 2008. Escribí:

Computer Go- El gran problema de AI
Computer Go en el Segundo Congreso Argentino de Go
AjGo- hacia un programa que juegue al go
Computer Go y el programa AjGo

En ese tiempo, fuí desarrollando mi programa de código abierto AjGo, donde estoy explorando algunas ideas sobre Computer Go.

Más enlaces sobre el tema en:

http://delicious.com/ajlopez/computergo
Computer Go en ajlopez.com

Desde hace años participo (modo lectura) en la gran lista de computer go:

http://computer-go.org/mailman/listinfo/computer-go

El grupo líder en el tema de IA en juegos de tablero y otros:

University of Alberta GAMES Group Home Page

Grid Computing y HPC

El año pasado, 2007, comencé a programar algunos ejemplos relacionados con Grid Computing, y ahora en el 2008, comencé a trabajar con High Performance Computing. Notablemente, el programa campeón mundial de Computer Go (y otros) están corriendo sobre un cluster de computadoras. Espero poder probar el ManyFacesOfGo de David Fotland, en un Windows HPC Server 2008 en cualquier momento. Otra idea a explorar es algorimos genéticos distribuidos en grilla o en cluster.

Para usar varias máquinas y tener más poder de cálculo, estoy explorando el camino de usar mi proyecto de código abierto AjMessages o el AjAgent. Por ahora, sirva como introducción:

AjMessages- hacia un procesador de mensajes

Microsoft Robotics

Desde el 2007, estoy trabajando con Microsoft Robotics, pero apenas he podido relacionarlo con IA. Algún intento en:

Genetic Algorithms with AjAgents and Concurrency and Coordination Runtime (CCR)
Algoritmos Genéticos con AjAgents y Concurrency and Coordination Runtime (CCR)
Lisp-like interpreter using DSS and VPL
Intérprete tipo Lisp usando DSS y VPL
Distributed agents using DSS-VPL
Agentes distribuidos usando DSS-VPL

Intérpretes

Estoy desarrollando dos intérpretes que me interesan: AjLisp, y AjProlog (versión anterior en AjProlog-0.2). Siempre me gustaron esos dos lenguajes, veremos si puedo aplicarlos para algún programa auto-modificable.

AjLisp- a Lisp interpreter in .NET

Generación de Código con IA

Espero poder incorporar a mi proyecto principal, AjGenesis, algo de IA. Pienso que un generador de código bien se puede asimilar a un sistema experto especial: debería, partiendo de un modelo incompleto, completarlo, tomar decisiones de diseño, inferir algunas partes del sistema, y generarlo.

IA, ciencia y filosofía

Desde los 90, me vengo topando con el problema mente-cerebro, y lo veo relacionado con IA. Críticas como las de Penrose, Hilary Putnam, y hasta Mario Bunge, me parecen interesantes, pero no las veo contundentes. Tengo pendiente postear sobre el tema, en mi blog personal no técnico, más filosófico. Apenas un preludio:

Inteligencia artificial, en la caída del conductismo

Bueno, espero que esto sirva como un pantallazo de mis intereses relacionados con IA, que está sobrevolando algunos proyectos míos, aunque no sea evidente aún.

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/
http://twitter.com/ajlopez

Inteligencia Artificial en Buenos Aires

lopez — Wed, 26 Nov 2008 22:18:00 GMT

Finalmente, ayer miércoles 26 de Noviembre, se realizó la primera reunión de Inteligencia Artificial en Buenos Aires. La idea era conocernos, entre quienes tenemos inquietudes sobre el tema, para ir formando algún grupo de interés, coordinar actividades, o simplemente intercambiar opiniones sobre el tema.

Asitieron a esta reunión:

Hernán Moraldo, que hace 10 años comenzó programando juegos, ahora está dedicado más a la matemática, trabajó con visión artificial, y ahora trabaja para Wolfram Research, la empresa desarrolladora de Mathematica.

Marcos Leguizamón, programador, interesado en electrónica, miembro de la lista de Robots Desarrolladores, desarrollando juegos para Sabarasa.

Javier Otaegui, quien es uno de los fundadores de Sabarasa, empresa dedicada a la creación de juegos, se presentó bajo otros "dos sombreros": fundador de Think an App, un nuevo emprendimiento que resuelve problemas difícil, utilizando inteligencia artificial (como algoritmos genéticos, en una aplicación para una petrolera), y con el sombre de miembro del ADVA, Asociación de Desarrolladores de Videojuegos de Argentina, que el año que viene que comenzar a aceptar papers para su congreso anual, incluyendo el tema de inteligencia artificial para juegos (ya había publicado por acá algo sobre ADVA en Exposición de Videojuegos Argentina- EVA 2008)

Manuel Aráoz, estudiante del ITBA, Instituto tecnológico Buenos Aires, interesado en inteligencia artificial, pero especialmente en las matemáticas.

Néstor Balich, que conoció la reunión por la lista de Robots Desarrolladores, interesado desde hace años en Inteligencia Artificial, profesor e investigador en robótica, que nos presentó su sitio dedicado a Robótica e Inteligencia Artificial http://www.robotia.com.ar/

La reunión comenzó unos minutos después de las 18:30, porque el bar donde íbamos a reunirnos estaba cerrado. Nos fuimos a un local a una cuadra, de la clásica La Continental.

No anoté la hora de finalización, pero debió ser cerca de las 21hs.

Así que se imaginarán la cantidad de temas, entusiasmo, intercambio de ideas que hubo. Se habló desde la escasez de programadores en Inteligencia Artificial en Argentina, el "gap" entre lo académico y lo práctico, los distintos apoyos para emprendedores, con sus altas y bajas, los lenguajes que se usan, empresas que necesitan IA, IA en el mundo, IA y robótica, el congreso de Inteligencia Computacional Aplicada del año que viene en Buenos Aires, IA en juegos (yo mencioné varios puntos de IA en Computer Go), la diferencia entre producir "papers" y trabajar en IA, etc. Se habló de algoritmos en juegos, de IA y otros que no, como path finder, y máquinas de estados. Se comentó el uso de IA en la implementación de Popego, al parecer, programado por la gente de Zauber. Se comentaron trabajos en IA en el país, como en robótica, futbol robótico, desarrollos con Prolog (en la Universidad del Comahue), actividad de IA en universidades (como el trabajo de Amandi en la Universidad del Centro). También se comentaron nuevas aplicaciones de IA como los de la empresa Evolution Robotics, uno de cuyos vicepresidentes es argentino. Pasamos por temas mas políticos, como la falta de relación entre la industria, el gobierno y lo académico, o sobre el próximo "polo tecnológico" de Buenos Aires, el llamado Centro Metropolitano de Tecnología, a situarse en Parque Patricios.

De mi parte, mostré algo de Computer Go en HPC Cluster, alguna funcionalidad de Microsoft Robotics, y el gran Big Dog de Boston Dynamics (No mencioné al AjGo y al AjLisp, aprovecho ahora para enlazarlos).

Como conclusión, vemos que hay puntos en común, ganas de hacer cosas, así que como "outcome" en concreto, armamos una lista en Google Groups, para seguir coordinando el grupo y para intercambiar ideas sobre Inteligencia Artificial. Los interesados en el tema, son bienvenidos a

IA Grupo

Como "outcome" personal, quería escribir este post, como minuta informal de la reunión.

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/
http://twitter.com/ajlopez

Reunión de Inteligencia Artificial en Buenos Aires

lopez — Thu, 20 Nov 2008 10:19:53 GMT

Una de las ramas más interesantes de la computación es la Inteligencia Artificial. Desde hace décadas, se ha ido tratando de obtener software que realice actividades que implican inteligencia. Han habido avances y retrocesos, "hypes" en el mercado y fracasos, caminos distintos como el manejo de símbolos, lógica y sistemas expertos, y por otro lado, redes neuronales, lógica difusa. Se ha llegado a un programa que le gana al campeón mundial de ajedrez. Ha aparecido la rama de la vida artificial, la creación de agentes autónomos, con cuerpo e interacción con el ambiente. La robótica también ha ido acompañando a la IA. Algoritmos genéticos, computación evolutiva, son más ramas que se han sumado.

Con la llegada de la llamada Web 2.0, con nuevas ideas y tecnologías como cloud computing, computación en grilla distribuida, web semántica, juegos en red, creo que hay una nueva oportunidad para la IA: integrarse en nuevos tipos de aplicaciones.

Hay siempre actividad por estos lares, en mi pais, Argentina, de gente interesada en Inteligencia Artificial, tando individuos, como grupos de interés en universidades y grupos de usuarios.

Hernán Moraldo tuvo una gran idea: convocar a los interesados en Inteligencia Artificial, por ahora acá en Buenos Aires. Hernán y yo nos leemos en Twitter, y sugerí una fecha y lugar. Todo quedó arreglado.

Así que hay una reunión el próximo miércoles 26 de Noviembre, a las 18:30hs. En un lugar mítico: el bar de San José y Rivadavia, en el barrio de Congreso, donde se reunía la gente de ciencia ficción (recuerdo haber asistido ahí por el 88) y luego los interesados en hacking (en los 90). Están invitados todos los interesados en Inteligencia Artificial. Voy a invitar a gente de la organización del congreso de Inteligencia Artificial del año que viene:

Congreso de Inteligencia Computacional Aplicada

en la Universidad de Palermo.

Yo arreglé todo para asistir ese día (no tengo curso a esa hora). Todos los interesados en el tema, están invitados. Espero que este sea el inicio de algo interesante. Hoy, en un mundo cada vez más conectado, desde acá, Argentina, podemos participar más fácilmente de lo que está pasando en el mundo. Y hasta aportar y crear.

Algunas de las ramas a explorar en IA en:

Temas Interesantes de Desarrollo de Software, Parte 1- Inteligencia Artificial

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/
http://twitter.com/ajlopez

Congreso de Inteligencia Computacional Aplicada

lopez — Thu, 11 Sep 2008 12:18:38 GMT

Hay un activo grupo de Inteligencia Artificial en la Universidad de Palermo, aquí en Buenos Aires, Argentina. Estan organizando un congreso internacional de Inteligencia Computacional Aplicada para el próximo año, 2009:

http://www.palermo.edu/ingenieria/cica.html

Congreso de Inteligencia Computacional Aplicada (CICA)

El 23 y 24 de julio de 2009 se llevará a cabo el Congreso de Inteligencia Computacional Aplicada (CICA), en la ciudad de Buenos Aires.
El Congreso, tiene por finalidad analizar el estado del arte de esta disciplina, desde un punto de vista de sus aplicaciones prácticas, en el país y en el mundo; generar un debate entre pares nacionales e internacionales sobre las problemáticas centrales de esta materia y promover la integración de profesionales, investigadores y empresas e industrias, en un marco en el que prevalecerán las innovaciones tecnológicas encaminadas a buscar el beneficio de la comunidad.
Contacto:
Tel: 5199-4520
E-mail: cica@palermo.edu

Yo ya tengo mis años, y lo que se llamaba Inteligencia Artificial, ha ido abriéndose en varias ramas. He asistido al auge y caida de los sistemas expertos en los 70 y 80, al relegamiento de los perceptrones de Rossenblat, ante el "ataque" del libro de Minsky y Papert, el resurgimiento y auge de las redes neuronales, lógica difusa y algoritmos genéticos, y a la vida artificial. Ahora, se llama Inteligencia Computacional a un grupo de disciplinas que se separan de la "vieja inteligencia artificial" (GOFAI "Good Old-Fashioned Artificial Intelligence").

Según la IEEE (según el artículo de la Wikipedia), las ramas de la inteligencia computacional son

Neural networks

Fuzzy systems

Evolutionary computation, incluyendo: genetic algorithms y genetic programming

Swarm intelligence, incluyendo particle swarm optimization

Estoy leyendo el libro Computational Intelligence: Concepts to Implementations, transcribo el primer párrafo del prefacio:

Several computational analytic tools have matured in the last 10 to 15 years that facilitate solving problems that were previously difficult or impossible to solve. These new analytical tools, known collectevily as computational intelligence tools, include artificial neural networks, fuzzy systems, and evolutionary computation. They have recently been combined among themselves as well as with more traditional approaches, such as statistical analysis, to solve extremely challenging problems...

Volviendo al congreso, en la página leo el "call for papers":

http://www.palermo.edu/ingenieria/Congreso_inteligencia_computacional/papers.html

Vean los comités:

http://www.palermo.edu/ingenieria/Congreso_inteligencia_computacional/comite_organizador.html

(todos nenes de pecho... ;-)

Y los keynote speakers:

http://www.palermo.edu/ingenieria/Congreso_inteligencia_computacional/invitados_especiales.html

Robert C. Berwick Ph.D.
  Professor of Computational Linguistics
  Department of Electrical Engineering and Computer Science
  Massachusetts Institute of Technology – USA
• Stan Franklin Ph.D.
  W. Harry Feinstone Interdisciplinary Research Professor
  Cognitive Computing Research Group
  Department of Computer Science
  Institute for Intelligent Systems
  The University of Memphis - USA
• Piero Bonissone Ph.D.
  Industrial Artificial Intelligence Lab
  Computing and Decision Sciences Technology area
General Electric Global Research – USA

Estoy muy interesado en el trabajo de Stan Franklin, y sus ideas y trabajos sobre inteligencia con un cuerpo, agentes autónomos que interaccionan con el ambiente, es un tema que tiene desde aplicaciones prácticas hasta aristas de filosofía, como el problema mente-cuerpo, y el problema de a conciencia. Pueden tomar un "paper" de hace diez años, para comenzar a entender a Franklin:

Autonomous Agents as Embodied AI

Artículos más recientes del bueno de Franklin en:

http://ccrg.cs.memphis.edu/papers.html

Robert Berwick, del MIT, es un referente en el tema de linguística computacional. Yo creo, que desde Chomsky, se ha puesto demasiado énfasis en el tema lenguaje, que debería ser estudiado como un epifenómeno de algo más nuclear, más profundo, de la mente, como es el tema de la representación, la formación de conceptos, y otras operaciones mentales.

No conocía a Piero Bonissone, que está, al parecer, interesado en todo lo que sea fuzzy systems. Ahora está en General Electric, desarrollando algoritmos para aplicar en salud, logística y aplicaciones financieras.

Más sobre Inteligencia Artificial en general en:

http://delicious.com/ajlopez/artificialintelligence

Gracias a Pablo Cababie, por avisarme de este evento, y por el esfuerzo que él y su grupo de la Universidad de Palermo estan poniendo para organizar este congreso, excelente iniciativa, que pone visible a la Argentina. Si bien el mundo es plano, es bueno tener visitantes del exterior, mostrar lo que se está haciendo en mi pais, y tener contacto directo con gente interesada en estos temas.

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/

AjLisp: un intérprete Lisp en .NET

lopez — Thu, 31 Jul 2008 13:30:41 GMT

Soy un entusiasta de escribir intérpretes, especialmente del tipo Lisp. Mi primer intérprete Lisp fue escrito al principio de los 80, usando el lenguaje assembler de un Intel 808x. Era un trabajo muy "geek". Una de las características más "tricky" de implementar es un recolector de basura (garbage collector). Por suerte, desde mediados de los 90 tenemos Java y su librería de clases como una tecnología ampliamente disponible con un garbage collector decente. En este siglo, .NET es la nueva plataforma de lenguajes con GC..

En el 2005, Martin Salias y yo dimos un TechNight, aquí en Buenos Aires, Argentina, para la oficina local de Microsoft. Trató sobre lenguajes implementados en .NET. Fue la primera vez que presenté F#, así como P# y otros. Despues de esa charla, la misma noche viajé a Mar del Plata, para dar otra charla sobre ASP.NET. Mar del Plata es una bella ciudad, en frente del océano Atlántico, a la que trato de volver cada año. Entonces, era mi primer visita luego de treinta años. En el viaje, "nació" AjLisp.

Esa versión era un intérprete Lisp escrito en Visual Basic .NET. El pasado domingo, lo porté a C# (usando alguna opción de menú de SharpDevelop, ¿alguna otra herramienta que conozcan?). El código original fue usado hace unas semanas en mi post sobre VPL:

Lisp-like interpreter using DSS and VPL
Intérprete tipo Lisp usando DSS y VPL

La nueva versión C# version está publicada en Google Code en:

http://code.google.com/p/ajlisp/

Me gusta Google Code: tiene soporte de SVN, asi que uso mi cliente local TortoiseSVN para enviar los cambios en el proyecto.

La solución

Tiene tres proyectos:

AjLisp: el proyecto núcleo, una librería, que puede ser invocada desde otra aplicación.

AjLisp.Tests: Todos los tests, usando NUnit 2.2.8. Si no tienen NUnit, pueden remover el proyecto de la solución.

AjLisp.Console: un simple programa de consola.

Los tipos

Una interfaz base es IAtom:

    public interface IAtom
    {
        bool IsAtom();
    }

Otra es IList:

    public interface IList
    {
        SymbolicExpression First
        {
            get;
            set;
        }

        SymbolicExpression Rest
        {
            get;
            set;
        }

        bool IsList();
    }

Todos los tipos derivan de una SymbolicExpression:

namespace AjLisp.Types
{
    public abstract class SymbolicExpression : IList, IAtom
    {
 ....

Implementé los tipos comunes a usar en un Lisp, como List, Atom, Identifier, Function (para invocar a primitivas y funciones generadas por lambdas), True, Nil...:

Existe una clase Environment para mantener valores asociados a nombres. Cada Environment tiene un Environment padre, para mantener una lista de ambientes con valores.

La clase Interpreter es la principal a manejar: tiene un Environment y define algunos nombres para las primitivas iniciales:

    public class Interpreter
    {
        private Environment environment = new Environment();

        public Interpreter()
        {
            Define("nil", Nil.Value);
            Define("t", True.Value);
            Define("cons", new SubrCons());
            Define("first", new SubrFirst());
            Define("car", new SubrFirst());
            Define("rest", new SubrRest());
            Define("cdr", new SubrRest());
            Define("list", new SubrList());
            Define("quote", new FSubrQuote());
            Define("append", new SubrAppend());
            Define("cond", new FSubrCond());
            Define("atom", new SubrAtom());
            Define("eval", new SubrEval());
            Define("null", new SubrNull());
            Define("lambda", new FSubrLambda());
            Define("progn", new FSubrProgN());
            Define("flambda", new FSubrFLambda());
            Define("nlambda", new FSubrNLambda());
            Define("mlambda", new FSubrMLambda());
            Define("numberp", new SubrNumberP());
            Define("functionp", new SubrFunctionP());
            Define("idp", new SubrIdP());
            Define("define", new FSubrDefine());
            Define("definef", new FSubrDefineF());
            Define("definen", new FSubrDefineN());
            Define("definem", new FSubrDefineM());
            Define("eq", new SubrEq());
            Define("if", new FSubrIf());
            Define("let", new FSubrLet());
            Define("lets", new FSubrLetS());
            Define("set", new SubrSet());
            Define("consp", new SubrConsP());
            Define("less", new SubrLess());
            Define("greater", new SubrGreater());
            Define("plus", new SubrPlus());
            Define("difference", new SubrDifference());
            Define("times", new SubrTimes());
            Define("quotient", new SubrQuotient());
            Define("remainder", new SubrRemainder());
        }

....

Uds. pueden escribir sus propias primitivas y agregarlas a este constructor.

Las primitivas

El intérprete tiene las primitivas usuales:

Hay primitivas, que antes de su invocación, evalúan los argumentos recibidos. Son las que derivan de Subr:

    public abstract class Subr : Function
    {
        public abstract SymbolicExpression Execute(SymbolicExpression args, Environment env);

        public override SymbolicExpression Apply(SymbolicExpression form, Environment env)
        {
            return Execute(form.Rest.Evaluate(env), env);
        }
    }

form.First es la función, y form.Rest es la lista de argumentos. Para evaluar el form, Function usa un objeto Environment.

Otras primitivas no evalúan sus argumentos, derivan de FSubr:

    public abstract class FSubr : Function
    {
        public abstract SymbolicExpression Execute(SymbolicExpression args, Environment env);

        public override SymbolicExpression Apply(SymbolicExpression form, Environment env)
        {
            return Execute(form.Rest, env);
        }
    }

Una de las primitivas más interesantes, es la implementación de lambda, llamada FSubrLambda:

    public class FSubrLambda : FSubr
    {
        public override SymbolicExpression Execute(SymbolicExpression args, Environment env)
        {
            return new SubrClosure(args.First, env, args.Rest);
        }
    }

Crea un Closure, una manera de recordar el Environment actual para usarlo en una futura invocación de la expresión lambda. Implementé también NLambda, FLambda, MLambda: N es por NonSpread (maneja su lista de argumentos como si fuera un solo argumento), F es cuando no son evaluados los argumentos antes de la invocación, y M es por Macro (tengo que revisar hasta donde implementé esta "feature").

Los tests

Toda la funcionaliad está cubierta por tests. Configuré el proyecto AjLisp.Test para ejecuter NUnit GUI:

La consola

AjLisp.Console es un simple programa de consola. Pueden ingresar una expresión y la evalúa:

Es tan simple, que hay que usar Control-C para salir... ;-).

Próximos pasos

Hay tanto para hacer. Quiero mejorar algunos puntos:

Reescribir interfaces y clases de base
Manejar e invocar objetos .NET nativos
Tratar a Reales y Enteros por separado (hoy a ambos, al operar, los trata como valores double)
Revisar Macro expansion
Mejor consola
Librería de ejemplos
Un manual mínimo

La idea es llegar a extender este mini lenguaje para ser usado como la base programación de agentes distribuidos. Sería bueno portarlo a Java. Entonces, la conducta de los agentes y su estado puede ser escrito en este lenguaje, y viajar a distintos nodos de la grilla, de forma independiente a la plataforma.

Bueno, son sueños. Ahora, el estado actual: está funcionando, y me divertí escribiéndolo. Disfruten!

(Este artículo es una traducción a Spanish, desde el Anglish (Angel's English) original:
AjLisp- a Lisp interpreter in .NET

)

Angel "Java" Lopez
http://www.ajlopez.com/en

Que lindo el guaguau: BigDog de Boston Dynamics

lopez — Thu, 24 Apr 2008 07:50:00 GMT

El domingo pasado, el bueno de Arvindra Sehmi referenció en un post suyo a un trabajo mío sobre una killer application que escribí: un scribble distribuido :-) Pero luego también escribió sobre este robot:

(Please visit the site to view this media)

Es de Boston Dynamics, according to Wikipedia:

http://www.bostondynamics.com/

http://en.wikipedia.org/wiki/Boston_Dynamics

Boston Dynamics is a small engineering and robotics design company best known for the development of BigDog, a quadruped robot designed for the U.S. military with funding from DARPA ^[1], and DI-Guy, COTS software for realistic human simulation. Early in the company's history, it worked with the American Systems Corporation under a contract from the Naval Air Warfare Center Training Systems Division (NAWCTSD) to replace naval training videos for aircraft launch operations with interactive 3D computer simulations featuring DI-Guy characters. ^[2]

Marc Raibert is the company's president and project manager. He spun the company off from the Massachusetts Institute of Technology in 1992.^[3]

Que bien resuelto está el tema de caminar y mantener el equilibrio y balance en distintas situaciones, y hasta hacer algún galope. Es notable que se haya logrado un algoritmo que implemente esa conducta. Según el bueno de Leandro Boffi (que además de mago se dedica a la robótica), eso se llama equilibrio dinámico.

Bueno, dejo algunos enlaces en

http://del.icio.us/ajlopez/robotics (últimamente, muy orientado a Microsoft Robotics Developer Studio)

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/

Temas Interesantes de Desarrollo de Software, Parte 1: Inteligencia Artificial

lopez — Sat, 05 Apr 2008 20:54:07 GMT

Hace unos meses, me preguntaban por email por algunos temas interesantes de desarrollo de software. La pregunta original estaba más orientada a tecnologías .NET, pero creo que puedo contestar de forma útil, de una manera más general. Igualmente, aparecerán temas de .NET en este post, y otro que seguirá.

Al plantearme escribir sobre el tema, me propuse cubrir varios temas que me interesan, pero vi entonces que si cubría todos en un solo artículo, sería muy largo. Así que va primero esta parte sobre Inteligencia Artificial, y más adelante esta semana, escribiré sobre otros temas que me parecen interesantes, como lenguajes en .NET, Software as a Service, Grid Computing, Generación de Código y Domain Specific Languages.

Trataré hoy algunos temas que me interesan y me llamaron la atención, dentro de lo que se ha llamado Inteligencia Artificial, un término muy amplio, y que cubre hoy varias disciplinas, con distintos objetivos.

Sobre la Inteligencia Artificial

¿Por qué proponer esta área como tema de desarrollo? Porque a la gran parte de los desarrolladores de software, nos fascina. ¿Qué mejor objetivo que conseguir comportamiento inteligente de un sistema de software y hardware? ¿Qué otro tema mueve más que éste en el ámbito de la creación de software? Ha sido desarrollado por décadas, y aún hay temas abiertos. Mas bien, el optimismo inicial que hizo que se denominara a esta rama "Inteligencia Artificial", se ha ido desvaneciendo, pero también ha habido éxitos, y nuevos caminos que no se habían tomado en principio (recordemos el abandono de los Perceptrones, debido en gran parte a la crítica de Minsky y Papert).

Quiero que quede claro que la inteligencia artificial hoy no es un área homogénea. Ha quedado bajo ese nombre histórico multitud de ramas. Y los métodos para implementar los objetivos planteados, van desde la fuerza bruta, hasta algoritmos novedosos (no naturales), hasta la emulación de lo que sabemos del funcionamiento de organismos naturales (humanos y no humanos).

Algoritmos genéticos

Creo que es un área ya bastante visitada, pero que tiene puntos de contacto con otros temas de este post, como vida artificial y aprendizaje automático. Para investigar:

Aprendizaje automático

Es un tema fascinante. La implementación de algoritmos que hagan que un sistema de software avance en su capacidad de resolver un problema, es un área alentadora. Muchos organismos aprenden durante su vida lo que no viene innato en su funcionamiento. ¿No podremos conseguir ese tipo de aprendizaje, o algún que lo emule? Esto resolvería el problema de programar todo el comportamiento de un agente inteligente "a priori", como cableado, y permitiría, bien implementado, adaptarse a un ambiente cambiante. Para estudiar

UCI Machine Learning Group
Machine Learning in Games
Machine Learning (AI on the Web)

Planeación

Uno de los primeros temas que aprendí hace décadas. Y sigue de alguna forma abierto a innovaciones. Es evidente que una de nuestras operaciones mentales es la formación de planes, aún planes parciales, incompletos, con información faltante. Pueden investigar leyendo:

(vi que en la Universidad Nacional del Centro de la Provincia de Buenos Aires, acá en Argentina, estuvieron trabajando en estos temas).

Vida Artificial

Se ha argumentado que, antes de conseguir comportamiento inteligente, hay que conseguir organismos, artificiales. Es una rama algo alejada de la IA principal, y hasta se la considera una rama aparte. A mí me gustaría incluirla en este post.

Siempre me pareció impresionante el proyecto Tierra:

http://www.his.atr.jp/~ray/tierra/index.html

Vean las "fotos" de:

http://www.his.atr.jp/~ray/pubs/images/index.html

Otro proyecto que también investiga el tema evolución es:

Darwin at home el resultado de aplicar Fuidiom
Fluidiom Implementado en Java, sería interesante implementar algo similar en .NET y DirectX/OpenGL

Juegos

Este es un tema para mí interesantísimo. Permite explorar algoritmos en un problema controlado, y aparte divertido. Para tener un panorama de los problemas actuales, hay que visitar el grupo de la Universidad de Alberta:

http://www.cs.ualberta.ca/~games/

Pueden visitar el grupo de Research de Microsoft:

Applied Games

Ahí encontraran uno de mis temas favoritos:

Computer Go in Microsoft

Hay otro grupo de investigación sobre el tema en Beijing:

Craking Go a cargo de Feng-hsiung Hsu

Lenguajes

Hay varias propuestas de lenguajes orientados a la Inteligencia Artificial. Pero que en general también se pueden utilizar en problemas generales. Algo interesante de un lenguaje para IA es que sus programas puedan "autoexaminarse" y modificarse a sí mismos. Revisaría algunas implementaciones en .NET como:

P#: A concurrent Prolog for .NET

Habría que investigar el uso de otros lenguajes, como Lisp y funcionales, como F#.

Ver

AI Programming (Lisp)
AI Programming (Prolog)

Visión por computadora

Una de las operaciones que como organismos ejecutamos fácilmente, ha sido un hueso rudo de roer. Una de las implementaciones más difundidas, de código abierto, accesible desde varios lenguajes (como C++ .NET) es:

Open Computer Vision Library

Más enlaces

Vision in AITopics

Una aplicación, no de visión, pero sí de reconocimiento de imágines

Photosynth

Robótica

Para entender el alcance que puede llegar a tener la aparición de herramientas de desarrollo para robótica, hay que leer el artículo clásico de Bill Gates:

A Robot in Every Home

Pueden estudiar todo lo que ofrece el

Microsoft Robotics Studio

Pueden programar en ambientes simulados, o con robots reales.

Otros enlaces

Recursos adicionales

Si tienen que ir a una sola página, con todo sobre Inteligencia Artificial, ir la página que mantiene Peter Norvig

AI on the Web

Siempre se discute qué es la Inteligencia Artificial:

What is Artificial Intelligence? (John McCarthy)
What is really AI? (discusión en GameDev)
What is Artificial Intelligence?

He dejado mis enlaces favoritos sobre estos y otros temas relacionados en:

http://del.icio.us/ajlopez/artificialintelligence
http://del.icio.us/ajlopez/artificiallife
http://del.icio.us/ajlopez/geneticalgorithm
http://del.icio.us/ajlopez/geneticalgorithms
http://del.icio.us/ajlopez/robotics
http://del.icio.us/ajlopez/computergo
http://www.ajlopez.com/ai

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/

AjGo: hacia un programa que juegue al go

lopez — Mon, 31 Mar 2008 00:40:43 GMT

El hacer un programa que pueda jugar al go ha sido un problema duro de roer en el ámbito de la inteligencia artificial. Para ir explorando algunas ideas, he escrito un programa que me sirve de framework para esa investigación. Pueden descargarlo desde

http://www.codeplex.com/ajgo

(esté el código fuente sin tener aún un release).

Lo comencé a programar hace unos años, y lo presenté el año pasado, en una charla que dí en el Segundo Congreso Argentino de Go, organizado por la Asociación Argentina de Go.

Este año me invitaron de nuevo a dar la charla en el Tercer Congreso (parece que no escarmentaron con la primera... ;-), y esta vez presenté más en profundidad este programa (el año pasado había estado dedicado a temas más generales, como Inteligencia Artificial, juegos y el estado del arte en Computer Go).

He dejado un post menos técnico, más dedicado al tema del juego que a la programación, en mi blog no técnico:

Computer Go y el programa AjGo

Hay otros programas mejores de Computer Go, pero siempre me gusta explorar por mí mismo algunos caminos, para comprender mejor el programa, y además, es más divertido... ;-). Pueden ver un programa más acabado, en la implementación de GNUGo

GNU Go - GNU Project - Free Software Foundation (FSF)

GNU Go - Wikipedia, the free encyclopedia

Sensei's Library- GNU Go

El AjGo

Está escrito en C# (antes lo había escrito en VBNet, pero preferí reescribirlo en C# para aprovechar algunos temas de refactoring, y con la esperanza de portarlo a otras plataformas más fácilmente, si a alguien le interesa).

La solución consta de tres proyectos:

El proyecto AjGo es una librería de clases donde está codificado el "core" del sistema.

El proyecto AjGo.Test es una serie de test automatizados usando NUnit, que me ha resultado de gran ayuda en la exploración de alternativas de programación. Cada vez que necesitaba escribir alguna funcionalidad nueva, siguiendo los preceptos de Test Driven Development, escribía primero el test, y luego el código que lo cumplía. Tengo todavía dos test en "rojo", pero que no afectan a la funcionalidad actual del programa.

El proyecto AjGo.WinForm es el que permite probar interactivamente el programa. La idea es colgar desde ese proyecto un formulario windows que me permita probar en el momento, la efectividad de algunos algoritmos y estrategias.

Si lanzan el proyecto de test, pueden ejecutarlo directamente. He colocado que, aunque sea un proyecto de librería de clases, igualmente ejecute el NUnit, necesitarán el NUnit instalado en alguna parte de su entorno de ejecución. Bajarlo de

NUnit - Home

Para conseguir que ese proyecto pueda lanzarse en modo de ejecución, deben modificar las propiedades del proyecto de test:

Si lo ejecutan, lanza la interface GUI del NUnit:

Detalles de implementación

Hay varias clases interesantes de comentar incluidas en el proyecto AjGo, quisiera hoy ocuparme brevemente de algunas.

Para los que conocen el juego, verán que están implementados los conceptos de:

Color
Position
Game
Group

Desde el año pasado estoy estudiando el tema de usar, aparte de color blanco y negro, otros colores para evaluar una posición.

    public enum Color
    {
        Empty = 0,
        Black = 1,
        White = 2,
        Border = 3,
        Blue = 4,
        Red = 5,
        Green = 6,
        Yellow = 7
    }

Verán que tengo entonces una enumeración que abarca otros colores, a explicar más abajo. Está incluido también el color "vacío" y el color "borde".

La clase Point representa un lugar en el tablero:

    public class Point
    {
        public short X;
        public short Y;

La clase Move es una combinación de Color y Point:

    public class Move
    {
        public Color Color;
        public Point Point;

        public Move(short x, short y, Color c)
        {
            Color = c;
            Point = new Point(x, y);
        }
...
    }

La clase Position describe una posición de juego (la posición puede tener un ancho y alto a determinar en ejecución):

    public class Position
    {
        private short width;
        private short height;

        private Color[,] cells;

        ...
    }

La clase Game es una de las más complejas, representa una posición, distintas evaluaciones, lista de movidas, y una cuenta hasta el momento de las piedras muertas por color:

    public class Game
    {
        private Position position;
        private List<Move> moves;
        private GroupPosition groupposition;
        private Position coloredposition;
        private GroupPosition coloredgroupposition;
        private ColorCount colorcount;
        private int deadblacks;
        private int deadwhites;
        ...
    }

La clase PointSet implementa un conjunto de puntos. Como conjunto no permite la repetición de puntos. Para comparar por igualdad instancias de Point se reimplementó el Equals y GetHashCode en esa clase. Hay métodos de clase para calcular intersección, unión y diferencia de conjuntos de puntos:

    public class PointSet
    {
        protected List<Point> points = new List<Point>();

        public static PointSet Union(PointSet ps1, PointSet ps2)
        {
            return new PointSet(ps1, ps2);
        }

        public static PointSet Intersect(PointSet ps1, PointSet ps2)
        {
            PointSet ps = new PointSet();

            foreach (Point pt in ps1.Points)
                if (ps2.Points.Contains(pt))
                    ps.Add(pt);

            return ps;
        }

        public static PointSet Difference(PointSet ps1, PointSet ps2)
        {
            PointSet ps = new PointSet();


            foreach (Point pt in ps1.Points)
                if (!ps2.Points.Contains(pt))
                    ps.Add(pt);

            return ps;
        }

        public PointSet()
        {
        }

        public PointSet(PointSet ps)
        {
            Add(ps);
        }
        ...
    }

Una extensión de PointSet es la clase Group, que además de un conjunto de puntos, tiene Color asociado:

    public class Group : PointSet
    {
        private PointSet liberties = new PointSet();
        private Color color;
        private GroupPosition groupposition;
        private GroupSet neighbours;
        ...
    }

Luego de Game, la clase más importante para la actual implementación es GroupPosition:

    public class GroupPosition
    {
        private Position position;
        private List<Group> groups;
        private Group[,] groupmap;
        private List<GroupSet> zones;

        public GroupPosition(Position pos)
        {
            position = pos;
            groups = new List<Group>();
        }
        ...
    }

Con instancias de esta clase, se calculan los grupos de piedras (cadenas de piedras conectadas), sus fronteras, vecinos, y zonas (grupos de grupos, de colores asociados, más sobre colores y zonas más adelante).

El Programa

Al ejecutar el tercer proyecto AjGo.WinForm aparece la ventana de prueba:

Con las opciones de Stone de la izquierda, se pueden ir colocando piedras de los colores blanco y negro. Una de las opciones del programa es sugerir posibles movidas, en base a patrones de jugadas que tiene en archivos de texto del directorio Matches del proyecto:

Con el botón de Colors se puede evaluar una posición "en colores":

Como explico en mi post de mi post no técnico:

Computer Go y el programa AjGo

Los puntos azules corresponden a puntos bajo la influencia negra, los amarillos están bajo el dominio blanco, los rojos están en disputa, y los verdes están en principio libres.
Una cadena de piedras conectadas, en AjGo se denomina grupo. Un conjunto de piedras negras "sumergidas" en un mar de piedras azules, es una zona negra. Lo mismo con piedras blancas y puntos amarillos.
He visto que para la evaluación de territorios, ojos, vida, y otros, conviene tomar en consideración la zona más que un grupo aislado (no lo sabía cuando le puse estos nombres, pero en GNUGo se llama cadena a lo que en AjGo llamo grupo, y se llama grupo a lo que en mi programa llamo zona).
En base a los colores, se pueden plantear distintos evaluaciones y objetivos. Una zona negra que no tengan ojos posibles o reales, está sin vida "eterna". Una zona que no esté en contacto con una zona verde, está rodeada, y si no tiene perspectivas de formar ojos, está en peligro.
Extender una zona, es aumentar su tamaño.
Conectar una zona, es fusionarla con otra del mismo color.
Rodear a una zona, es desconectarla de zonas verdes (disminuir lo que llamo "vida verde").
El programa igualmente contempla que una zona verde que en su frontera sólo tenga puntos azules, es considerada un "ojo verde" (controlado por piedras negras). Uno de las evaluaciones que estoy probando pondera que una zona verde es tal porcentaje "blanca" y tal otro porcentaje "negra" en base a la cantidad de puntos azules, amarillos y rojos de su frontera.

Hay más detalles relacionados con el juego en ese post.

Tengo que mejorar varios puntos. Uno importante, son los algoritmos que tengo implementados para buscar en un árbol de jugadas. Otro, son las clases que evalúan una posición en forma estática. Ambos están en directorios del proyecto AjGo. Estos son los "Agents" de búsqueda en árbol:

Trabajo futuro

Hay mucho para hacer. Me gustaría terminar de pulir la exploración de árbol, la resolución de problemas de vida y muerte, tener un planeador con objetivos, evaluadores estáticos de posición, evaluadores tácticos con exploración de árbol, parámetros variables, algoritmos genéticos.... Bueno, son muchas cosas. Hay que ir paso a paso. Creo que lo primero va a ser mejorar el tema de recorrido de árbol. Vendrán más posts con algunos detalles más finos sobre la implementación actual.

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/

Computer Go en el Segundo Congreso Argentino de Go

lopez — Wed, 28 Mar 2007 12:03:34 GMT

La Asociación Argentina de Go celebra este próximo fin de semana el Segundo Congreso de Go

http://www.go.org.ar/page.php?name=congreso2007

Hay actividades desde el viernes al lunes. El viernes, habrá una charla sobre Computer Go, recuerden que el Go es el gran desafío de la Inteligencia Artificial, en juegos.

En esa charla, presentaré cuál es la historia del Computer Go, su estado actual, algoritmos intentados, probaremos algún programa, y discutiremos cuál podría ser el camino a tomar para un programa que venza finalmente a un simple humano.... :-)

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/

Los libros de Martín Salías

lopez — Sat, 03 Mar 2007 09:28:23 GMT

El bueno de Martín Salías siempre se ha caracterizado por su amabilidad, y su disposición a compartir todo lo que conoce, desde arquitectura de software hasta sus opiniones sobre Virilio. Al contrario de mí, que no me desprendo de mis libros (me temo que son mi debilidad), él los ofrece a sus compañeros de trabajo, y aún más, a los socios del Microsoft User Groups de Argentina: un santo varón :-)

Independientemente de si Ud. cae en algunas de esas categorías, le recomiendo una visita a la lista de libros

Technical Bookshelf

Hay de todo: inteligencia artificial, historia de la computación, el venerable FoxPro, arquitectura de software, sistemas operativos, .NET y ASP.NET, objetos, XML, metodologías ágiles, y más....

Pasen, vean y tomen!

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/

Computer Go: El gran problema de AI

lopez — Mon, 15 Jan 2007 01:01:00 GMT

Desde hace algunos años, estoy interesado en algunas ramas de lo que se llama Inteligencia Artificial. Convengamos que el término es algo ampuloso, y refleja el entusiasmo de fines de los años 50, cuando en una reunión de especialista se acuñó el término. La Artificial Intelligence o AI ha pasado por varias etapas y viscisitudes, ha habido de todo, desde triunfos y fracasos, hasta ramas nuevas (agentes, redes neuronales, aprendizaje automático) que han ido apareciendo. Realmente es un tema fascinante, pero tal vez demasiado amplio.

Pueden ver algunos enlaces desordenados que colecciono en

http://www.ajlopez.com/ia/

He mantenido, de alguna manera, el interés en una rama: su aplicación a los juegos. Pueden visitar el excelente sitio del grupo GAMES de la Universidad de Alberta (Canadá):

http://www.cs.ualberta.ca/~games/

para encontrar mayor información, estupenda. Si Uds. investigan un poco, encontrarán que a lo largo de todos estos años, hay un juego que ha resistido las distintas aproximaciones que se han intentado para dominarlo. Pueden encontrar más información sobre el juego en el sitio de la Asociación Argentina de Go:

http://www.go.org.ar/

en especial, el ya clásico artículo del bueno de Franklin Bassarsky:

Por qué Aprender a jugar al Go
http://www.go.org.ar/actividades/porque.html

Mientras que Deep Blue el siglo pasado derrotó a Kasparov, en ajedrez, el mejor programa de go del planeta apenas si puede enfrentar a un verdadero experto en el juego. Para conocer más sobre la situación actual, visitar el interminable y subyugante

http://gobase.org/

En los últimos años, ha surgido el wiki

http://senseis.xmp.net/

donde encontrarán múltiples temas tratados, por ejemplo

http://senseis.xmp.net/?ComputerGoProgramming
http://senseis.xmp.net/?ComputerGoAlgorithms

Un clásico es el algoritmo de Benson (solo como botón de muestra de cómo apareció hace años, y luego han ido apareciendo otras ideas para explicar y acercar el Go a la AI):

http://senseis.xmp.net/?BensonsAlgorithm

También como botón de muestra de la cantidad de "papers" que mueve el tema, ver

http://erikvanderwerf.tengen.nl/publications.html

LA lista de correo sobre el tema es:

computer-go mailing list
computer-go@computer-go.org
http://www.computer-go.org/mailman/listinfo/computer-go/

Se imaginaran entonces, que no puede faltar.... el AjGo. Sí, estoy pasando a .NET algunas ideas. La principal es concentrarme primero en planes, que traten de cumplir con 4 objetivos básicos:

- Aumentar el territorio propio
- Disminuir el territorio enemigo
- Asegurar la vida de las piedras propias
- Capturar piedras enemigas

Hace unos años investigué distintas formas de calcular la influencia y territorio, basado en conceptos que todos en computer go tratan alguna vez: "iluminación", "campos de fuerza".... En este nuevo intento, he visto que es más interesante simplemente separar en grupos, usando para visualizar el resultado distintos colores. Un ejemplo (una posición algo ridícula para un juego real, pero interesante para mí) es:

Podría explicar un poco más en detalle el coloreo, pero basta decir que los azules indican cercanía a piedra negra, los rojos cercanía a piedra blanca, amarillo cercanía a ambos colores, verde libre de cercanía. Los cuatro objetivos básicos los puedo expresar en deltas en esos coloreos. Me parece que el concepto de grupo coloreado, y su aumento o disminución, es un camino interesante a explorar. Por ejemplo, rodear a un grupo enemigo es, en principio, asimilable a "disminuir sus verdes", los verdes que estan en contacto con ese grupo.

Supongo que alguien ya lo habrá seguido, pero de alguna forma, con esto estoy aprendiendo sobre la dificultad del problema. Tengo que analizar la táctica a seguir para cumplir con cada plan sugerido. Igualmente, algo de algoritmo de sisho generalizado está siendo incorporado. Falta la hercúlea tarea de resolver:

- Tácticas de corte
- Tácticas de conexión
- Tácticas de vida y muerte

Espero poder postear algo interesante cuando tenga algo más armado, código incluído.

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/