En el post anterior, hablamos un poco de los dos dialectos más extendidos actualmente del lenguaje Lisp, un lenguaje que aporta bastantes funcionalidades interesantes a la hora de tratar con ciertos problemas de inteligencia artificial.

Los dos dialectos que comentamos son Common Lisp y Scheme. El primero es un estándar ANSI y tiene una larga colección de librerías estandarizadas, lo que hace de él un lenguaje apto para proyectos grandes. Scheme por su parte, se construye con una meta clara: la simplicidad y la funcionalidad. Se desarrolla con la intención de ofrecer las características principales de Lisp (por eso es un dialecto y no un lenguaje aparte), pero evitando librerías y demás “paja”. Esto hace de él un lenguaje muy interesante para experimentar y para aprender, y por eso es el lenguaje al que he decidido dedicar este post, puesto que aquí no vamos a embarcarnos en un proyecto grande. Simplemente quiero mostrar soporte y recursos sobre este lenguaje para que aquel que quiera, tenga un arranque más sencillo; además, de este modo si alguna vez decidimos implementar algo y utilizar para ello este lenguaje, pues tenemos una base.

Para comenzar, indicar el sitio oficial del lenguaje, en el que se ofrecen algunos links a otras páginas con recursos y software sobre Scheme. Esta página oficial se encuentra dentro del dominio csail.mit.edu. Como comentamos, el lenguaje fue desarrollado precisamente en esta universidad, el MIT, al igual que su padre, Lisp. Y más concretamente en el laboratorio de ciencias de la computación e inteligencia artificial (CSAIL).

Entre los links de recursos que merece la pena mencionar, se encuentra Schemers.org, el que supone, desde mi punto de vista, el punto de partida para aprender el lenguaje. Encontramos recursos de todo tipo, manuales, libros, así como software y una larga lista de implementaciones del lenguaje. Quiero aclarar que cuando hablo de implementaciones del lenguaje, me refiero a software capaz de compilar o interpretar el código Scheme para poder luego ejecutarlo.

La referencia oficial del lenguaje se va actualizando en esta página, donde podemos encontrar actualmente dicho documento, en formato pdf, de apenas 90 páginas (de ahí la simplicidad [que no facilidad necesariamente]). Esta referencia es asimismo el estándar de facto del lenguaje.

En cuanto al software, es decir, a las distintas implementaciones de Scheme, en Schemers.org ofrecen esta larga lista. A la hora de elegir una implementación con respecto a otra tenemos que atender a las distintas características que pueden estar ofreciéndonos, puesto que hay implementaciones que convierten el código Scheme en código bytecode de Java, o implementaciones que nos permiten empotrar código Scheme en Common Lisp (lo que tiene desde luego cierto interés)…

Además es importante tener claro qué versión de la referencia de Scheme implementa cada software. La actual es R6RS, pero podemos encontrar a día de hoy software que implementa perfectamente la versión R4RS. Las diferencias entre versiones suelen ser mínimas, pero es importante tenerlas claras a la hora de instalar un software y comenzar a desarrollar nuestros programas. El problema en este ámbito es que no existe ninguna implementación de referencia u oficial, y por ello debemos prestar especial atención a la hora de utilizar una implementación u otra, como hemos comentado.

Basándome en varios criterios distintos que comento a continuación (y una larga serie de infructuosas pruebas) me decido por recomendar Guile. Guile es un proyecto GNU (lo que siempre da ciertas garantías si está mantenido, como es el caso) que implementa el lenguaje Scheme, ofreciendo a su vez tres modos principales de uso. Cuando lo instalamos (sólo para sistemas Unix-like), podemos ejecutarlo en línea de comandos, e introducir directamente las sentencias Scheme que queramos, y Guile, que actúa de intérprete, nos dará las respuestas. Por otro lado, (el más cómodo para probar Scheme), podemos escribir scripts y ejecutarlos, del mismo modo que haríamos con un lenguaje de scripting como Bash o Perl, lo cual es realmente interesante. Y finalmente, y probablemente la característica estrella de esta implementación, es que nos permite utilizar Scheme como un lenguaje de extensión, proveyendo una librería con la funcionalidad de Scheme, que podremos integrar en un proyecto en C, por ejemplo, de modo que tenemos nuestra aplicación en C que en un momento dado hace uso de la funcionalidad que le da Scheme, lo cual lo hace extremadamente versátil.

Para finalizar, quiero dejar claro que existen muchas otras implementaciones que pueden ser igual de útiles a la hora de probar Scheme. Quizá la más directa sea la implementación que realizan en el propio MIT, MIT-Scheme; la razón por la que no es la que he elegido es porque actualmente tiene un bug sobre sistemas Debian-like que corran AppArmor. Mi caso es tal, y por ello era imposible utilizar tal implementación sin reconfigurar ciertos parámetros de mi sistema. De momento me gusta Guile, que es igualmente sencillo de instalar y de utilizar, y además tiene una muy buena documentación en la página.

Ya por último, un interesante curso del OCW del MIT, en el que se utiliza Scheme como principal lenguaje, y que se basa en este libro, considerado como una joya, tanto para aprender Scheme, como para aprender los entresijos de la programación.

En el pasado post comenté un poco algunos de los lenguajes utilizados para tareas relacionadas con la inteligencia artificial. Hablé de Lisp, un lenguaje creado expresamente para tal fin, que data ya de hace bastante, está muy testado y sigue ahí, ya que los resultados que podemos conseguir con él son bastante beneficiosos en muchos casos.

Hoy vamos a ver un poco más en profundidad algunas cosas que es necesario conocer a priori de este lenguaje, para aquellos que quieran probarlo por su cuenta. Además al final voy a colocar algunas referencias a sitios donde podemos aprender más sobre este lenguaje y todo lo que le rodea.

Para empezar, Lisp es el segundo lenguaje de alto nivel más antiguo de los existentes (Fortran es el primero), y este hecho es el que genera precisamente la variedad de implementaciones de Lisp que podemos encontrar hoy día. Digo implementaciones porque realmente existen “dialectos” del lenguaje, que han ido desarrollándose para cumplir ciertos objetivos a lo largo del tiempo, adaptaciones que han ido haciéndose y que en algunos casos se han extendido. Me parece que es una buena idea conocer un poco de qué van estos dialectos para saber por dónde empezar; si bien es cierto que una vez que dominemos uno, los cambios son más bien escasos, simplemente algunas reglas a tener en cuenta y quizá algunas partes de la sintaxis.

Alguna vez hemos hablado de las máquinas Lisp, unos dispositivos usados en la década de los 80 cuyo hardware estaba preparado específicamente para ejecutar código Lisp, haciendo los programas implementados en este lenguaje mucho más veloces y eficientes. Esto no escaló demasiado, y no tardaron en comenzar a surgir los compiladores de Lisp para máquinas de propósito general, que son los que podemos utilizar nosotros para desarrollar y los que impulsaron el lenguaje cuando la IA atravesaba uno de sus inviernos.

Los dos dialectos más conocidos y extendidos de Lisp son Common Lisp y Scheme, de hecho si queremos probar este lenguaje, lo mejor será que escojamos entre alguno de estos dos dialectos, pues son las implementaciones más utilizadas a día de hoy y las que quizá tengan más soporte actualmente.

Sobre Common Lisp (CL) merece la pena destacar que es un estándar ANSI, que surgió para estandarizar y aunar las innumerables implementaciones distintas de Lisp que había en ese momento. Podemos encontrar herramientas de software libre para poder desarrollar utilizando este lenguaje. Indicar además que existen diversidad de librerías para CL lo que lo hace quizá el más cómodo de utilizar si queremos embarcarnos en un proyecto grande.

Scheme por otro lado busca la sencillez, es un dialecto muy versátil que si bien mantiene todos los principios de la programación en Lisp, restringe algunas características que podemos encontrar en CL, y sigue una filosofía minimalista. Además no dispone del amplio número de librerias de CL. Posiblemente para empezar sea un lenguaje más cómodo que CL, porque aprenderemos con él lo básico y si en un futuro necesitamos librerías más amplias, pues tenemos CL. Además debido a las similitudes, el cambio nos será prácticamente transparente. Scheme es de hecho un lenguaje muy utilizado en universidades para enseñar los distintos paradigmas de programación, ya que pese a su sencillez mantiene una alta versatilidad en este sentido, y simplifica bastante la labor.

A continuación os dejo algunas referencias para que echéis un vistazo, y en el próximo post volvemos al tema.

• CL:

Manual: Common Lisp the Language, 2nd Edition, escrito por Guy L. Steele Jr.
Otra versión del mismo, aquí.

• Scheme:

El documento oficial (unas 90 pags.)
La casa de Scheme, en el MIT, con software, y documentación varia.

Lo dicho, que esto se alarga.

Abrimos esta cadena de posts con la siguiente pregunta: ¿cómo aplico a algo inteligencia?.

Bueno, por pasos: primero tendremos que disponer de algo a lo que se pueda aplicar inteligencia. Por hacerlo sencillo, vamos a suponer una simple aplicación de escritorio. Después tendremos que tener claros los objetivos que queremos que esa aplicación cumpla, y esto es un paso muy laborioso, porque además debemos conocer bien la tecnología para no pensar cosas utópicas, y elegir los caminos más acertados. Una vez tenemos claros los objetivos, si conocemos bien la tecnología, deberemos diseñar una solución, es decir, deberemos pensar de qué forma esta aplicación va a tomar decisiones “inteligentes”. Puede que nos suponga incluir algoritmos de búsqueda, puede que tengamos que aplicar conceptos de lógica, y probablemente tendremos que tratar con datos, con lo cual también sería interesante presentar tales datos del modo más cómodo que nos convenga.

Y una vez nos encontramos con un diseño hecho, pues sólo nos quedará implementarlo. ¿Qué lenguaje es el más adecuado?.

Con la pregunta ya planteada, vamos a pasar a responderla, puesto que es bien sencillo: en general, no hay un lenguaje óptimo para cualquier tarea que conlleve utilización de técnicas de IA. Si vamos a desplegar la aplicación en un robot, pues probablemente C o Ada sean los lenguajes que más beneficios puedan aportarnos, pero por las peculiaridades de los lenguajes en sí y no porque nos provean de soluciones de IA de forma directa; por eso esta decisión engloba muchos factores que deben ser discutidos por expertos en tal área.

Si hablamos de aplicaciones de escritorio, como en el ejemplo de arriba, con un lenguaje de alto nivel (como pueda ser C++, Java, o C#/.NET) puede ser suficiente, puesto que supondrá aplicar algoritmos con una fuerte fuente matemática.

La gracia viene cuando necesitamos manejar datos a la vez que construcciones programáticas que operen dichos datos, y cuando debemos realizar esto de una forma continuada y masiva. Esto de manejar datos, operándolos, modificando ciertos atributos, mezclándolos, etc, pues suena a sistema experto, ¿no? Si recordamos, un sistema experto se centraba en un dominio de conocimiento para resolver problemas asociados a tal dominio. Para este fin, este sistema debe manejar datos del entorno, datos que le introduzcamos, y los irá operando para hallar una respuesta o un conjunto de éstas.

Además, podemos entender que casi cualquier aplicación a la que queramos dotar con técnicas de IA va a tener ciertos módulos que manejen datos como si de un sistema experto se tratase (probablemente sea así), y es precisamente aquí donde introducimos Lisp.

; ---FACTORIAL----
;Definición matemática
; Factorial(x) = 1 si x=0 caso base
; x*factorial(x-1) si x>0 caso recursivo
;Función factorial hecha con recursividad no final
(defun factorial (n)
(if (= 0 n)
1 ; caso base
(* n (factorial (- n 1))))) ; caso recursivo
(factorial 4) ;esto nos devolvería 24=4*3*2*1

Lisp es un lenguaje de programacion de alto nivel y declarativo, que data del 58, diseñado por John McCarthy en el MIT, y desarrollado precisamente para facilitar las tareas en las que es abrumadora la necesidad de cruzar datos con operaciones, y modificar éstos segun muchísimos criterios para obtener una salida, que a su vez pasará por otra operacion que hará que estos datos… etc, etc. Es un lenguaje cuya estructura fundamental es la lista, y es precisamente este hecho el que facilita ciertas tareas, y por lo que ha sido usado ampliamente desde sus inicios para la IA. Detallar más explícitamente por qué es apto para ese tipo de aplicaciones es una tarea difícil de realizar; el fin del post era arrojar algo de luz sobre aspectos de más bajo nivel de la IA (como es su implementación), comentar qué herramientas se utilizan en algunos casos, puesto que como es de esperar, herramientas para la IA hay infinitas, así como lenguajes, técnicas, etc.

….Esperando comentarios de cualquier tipo…

Concluía el anterior post, diciendo que al inicio existía una sensación esperanzadora, basada en la idea de que con la IA se resolverían muchísimos de los problemas de aquel entonces, y comenté que finalmente se desvanecería esa sensación general, terminaría lo que aquí clasificaremos como la primera época, la época romántica de la IA, los inicios.

Precisamente termina esta época con la primera crisis que sufre la rama de la que hablamos, pero antes de llegar a este punto, e intentar ver por qué se pierde esta esperanza, quedan muchos eventos que revisar y que merecen especial mención, por ello, este post está dedicado a nombrar y comentar algunos de los que considero más relevantes.

Para comenzar, voy a hablar un poco de un programa desarrollado por Herbert Simon y Allen Newell en el 57, me refiero al “General Problem Solver”, lo mencioné en el post anterior y dije que su nombre reflejaba esa idea inicial de buscar una solución a todos los problemas con la IA. Concretamente, este programa podría resolver cualquier problema, eso sí, tenía que ser un problema que se pudiera formalizar a la perfección, y aun así no cumplía siempre con las expectativas. Con formalizar un problema, me refiero a definir las variables que intervendrán en el problema, así como las reglas que son aplicables sobre esas variables. Si podemos hacer esto, entonces tenemos un problema formalizado, que es una base para darle a una máquina y que pueda ser procesable. Por supuesto, no todos los problemas de la vida real son formalizables en ese sentido, y esto es algo de lo que los creadores del GPS eran totalmente conscientes, pero aun así, había quien defendía que sí era posible ir más allá y conseguir incluso mejores resultados. El funcionamiento a nivel técnico del GPS suponía el uso de métodos heurísticos, para ir hallando sub-soluciones que le llevarán a la solución final, que sería en el caso óptimo la resolución del problema. De cómo se plantean, formalizan y resuelven problemas mediante búsqueda se está ocupando Proteus-IV (aquí y siguientes), así que no entraremos en más detalle.

Hablando de formalizar problemas, a la hora de escribir los programas para representar o resolverlos, no existía por entonces un lenguaje que estuviera claramente enfocado a este fin, que facilitase esta representación mediante unas estructuras de datos más acomodadas o mediante unos procedimientos más cercanos. El GPS anteriormente comentado estaba escrito en IPL, un lenguaje de muy bajo nivel. John McCarthy inventa en el 58 el lenguaje de programación Lisp , el que ha sido desde entonces uno de los más utilizados lenguajes de programación en Inteligencia Artificial. Algunas características que le hacen tan aconsejable para esta ciencia son la facilidad a la hora de emplear notaciones matemáticas, así como la estructura base del lenguaje, la lista (de donde proviene su nombre, por cierto).

No puede terminar el post sin comentar el nacimiento del MIT Ai Lab, el que ha sido uno de los mayores propulsores de la Inteligencia Artificial, por sus investigaciones y por sus logros. Fue fundado en el 59 por el mismo creador que el lenguaje Lisp y por Marvin Minsky, a quien también nombramos en el post anterior. El MIT AI Lab aparecerá en muchas más ocasiones porque, como se ha dicho, ha sido un gran impulsor de la rama desde los inicios de su existencia; por eso, de momento no comentaremos nada más.

El último post de los Inicios de la IA estará dedicado a ver un poco por qué esta idea que he intentado reflejar a grandes rasgos en estos dos primeros posts va esfumándose, y se forja una nueva visión que perdurará durante las siguientes décadas. Hasta entonces y como siempre, sugerencias, comentarios y sobre todo más cosas que ocurrieran en ese inicio y que queráis comentar.