Monday, November 26, 2012

Reporte 3 [CLASE]
Perceptron que reconoce un "AND"

Los perceptrones son los sistemas neuronales más simples, aunque no por ello resultan exentos de utilidad ya que son, a pesar de sus inherentes limitaciones, eficientes procesadores de información.  Así pues, su estudio como entidad independiente está plenamente justificado. Dado que algunas de sus características,tales como su comportamiento geométrico y estadístico, la filosofía de sus algoritmos de aprendizaje, el balance que se debe efectuar en su diseño entre el poder de aproximación y el de estimación, son extensibles a otros sistemas neuronales más complicados, el análisis en detalle de estos sencillos dispositivos puede dar una idea de las ventajas y limitaciones de otras estructuras relacionadas.


El perceptrón en su forma más general tiene una arquitectura que se puede descomponer en tres partes:

1. Una serie de procesadores-φ que realizan una transformación entre el espacio de entrada X de dimensión d y el espacio V de dimensión M (pre-procesado).
2. Una suma ponderada de los M componentes del vector de entrada transformado más un valor de polarización (o umbral).
3. Una transformación τ realizada sobre la suma ponderada

Unidad Basica de un perceptron


En el perceptrón se distinguen dos formas de operación principales, dependiendo de si la función τ toma valores discretos o continuos:

1. Como aproximador de funciones de salida binaria o clasificador. Cuando  τ(g(x)) toma valores discretos (+1,-1 ó 1,0) el perceptrón se puede considerar como un clasificador de patrones que pertenecen a dos clases. Es decir que el perceptrón es una función que realiza una transformación no lineal del tipo x∈ℜ d →{-1,+1} o {0,1} asignando así x a la clase 1 cuando toma el valor 1 y a la clase 2 cuando toma el valor -1 (ó 0). 
Un caso particular de funciones de salida binaria son las funciones lógicas que son del tipo {0,1} d→{0,1}. De esta forma se puede afirmar que un perceptron (en su forma más general) puede implementar cualquier función del álgebra de Boole.

2. Como aproximador de funciones reales. Cuando τ(g(x)) toma valores continuos (ℜ) el perceptrón se puede utilizar como un aproximador de funciones reales. Si  τ es lineal, o sea  τ(g(X))=g(X), el perceptrón se convierte en un aproximador de funciones lineal teniendo {f1(x), f2(x), ..., fM(x), 1} como funciones básicas



Básicamente el problema del aprendizaje en el caso del perceptrón se puede descomponer como veremos a continuación en dos pasos:

1. Proponer una función a minimizar cuya solución implique conseguir lo que perseguimos
(por ejemplo, conseguir un discriminante que separe dos clases linealmente separables o que separe dos clases linealmente no separables de la mejor forma posible).

2. Proponer un método de optimización que nos permita a través del conjunto de entrenamiento (de tamaño N) obtener la solución deseada. Esto es, un algoritmo que sea capaz de calcular (en un  tiempo finito) los parámetros del dispositivo que sean solución del sistema de N ecuaciones resultantes. Puesto que se puede proponer infinidad de funciones a minimizar y métodos de optimización que minimicen dichas funciones, restringiremos nuestro estudio a varias funciones y en concreto a un único método de optimización que las minimice, el basado en el descenso (o ascenso) de gradiente estocástico.

Además dichos algoritmos para dos casos bien diferenciados:

1) Cuando τ es una función del tipo escalón y por ello no derivable (perceptrones tipo I)
2) Cuando τ es una función real, continua y derivable (perceptrones tipo II



Ahora bien para el caso de nuestro reporte 3 se nos pide hacer que el codigo en python de un "NAND" se transforme en un AND y checar las diferencias entre el NAND y AND una vez ejecutados los codigos para que de esta manera queden ejemplificadas las funcionalidades diversas que puede presentar un perceptrón. He aqui entonces el codigo en python de el ejemplo de un NAND







Ahora bien la modificación a este codigo funcionando como un AND sería:






De manera que mediante esta modificación que se le hace al entrenamiento (training set) obtenemos valores diferentes, ya que en lugar de obtener los resultados del NAND que aparecen arriba, estos generan una serie de 9 iteraciones antes de obtener la normalización. A diferencia de estos resultados en el cambio generado para el AND, aparecen en la primer serie un resultado de cero para todos y solamente 2 series para la corrida, ya que los resultados generados siempre se mantienen cercanos.



Con estas observaciones en el código obtenido podemos realizar conclusiones sobre los perceptrones, En la etapa de aprendizaje, el objetivo que se persigue es hacer mínima la discrepancia o error entre la salida obtenida por la red y la salida deseada por el usuario ante la presentación de un conjunto de patrones denominado grupo de entrenamiento. Sin embargo cuando el perceptron va ganando aprendizaje, llega a un punto de normalización, como se puede ver en la grafica indicada,



donde se puede ver claramente el margen de error y como este conforme aumentan las iteraciones va disminuyendo considerablemente, hasta alcanzar lo que se denomina "normalización" o la normal, este tipo de algoritmos podemos implementarlos en sistemas, donde nos interesa que el aprendizaje del perceptron, pueda estar ligado a eventos o cambios en eventos, con los que pueda producirse una estimación o anticipación mediante una predicción establecida por medio del aprendizaje histórico y que esta a su vez, genere información cada vez mas acertada y con un margen de error cada vez menor.

De igual forma podemos ver en la gráfica como las validaciones que hagamos a este codigo conforme pasen las iteraciones, obtenemos una linea muy similar a la del error de entrenamiento, la cual nos ayuda a ver el comportamiento del perceptron en cuanto a numero de iteraciones y el numero de errores encontrados, lo que nos provee información clara y concisa de lo que esta sucediendo en el entrenamiento del perceptrón.

Video demostrativo en C++ de como implementa y trabaja un perceptrón una tarea de entrenamiento, no se tiene un video propio, por ejemplo de los códigos modificados, para observar los cambios en los resultados arrojados, así que optamos por mostrar un trabajo de la red utilizando lenguaje C++, esperando pueda ampliarse aun mas el panorama de el funcionamiento de un perceptron y sus alcances.




Bibliografía Consultada

  • Arana, E., Delicado, P., Martí-Bonmatí, L. (1999). Validation procedures in radiologic diagnostic 
  • models. Neural network and logistic regression. Investigative Radiology, 34(10), 636-642.  
  • Arbib, M.A. (Ed.) (1995). The handbook of brain theory and neural networks. Cambridge, Mass.: 
  • MIT Press.  
  • Arbib, M.A., Erdi, P. y Szentagothai, J. (1997). !eural organization: structure, function and 
  • dynamics. Cambridge, Mass.: MIT Press.  
  • Bahbah, A.G. y Girgis, A.A. (1999). Input feature selection for real-time transient stability 
  • assessment for artificial neural network (ANN) using ANN sensitivity analysis. Proceedings of the 21 
  • st International Conference on Power Industry Computer Applications, 295-300.  
  • Battiti, R. (1992). First and second order methods for learning: between steepest descent and 
  • Newton's method. !eural Computation, 4(2), 141-166.  
  • Bishop, C.M. (1995). !eural networks for pattern recognition. New York: Oxford University Press.  
  • De Lillo, A. y Meraviglia, C. (1998). The role of social determinants on men´s and women´s mobility 
  • in Italy. A comparison of discriminant analysis and artificial neural networks. Substance Use and 
  • Misuse, 33(3), 751-764.  
  • Fahlman, S.E. (1988). Faster-learning variations on back-propagation: an empirical study. 
  • Proceedings of the 1988 Connectionist Models Summer School, 38-51.

Imagenes utilizadas de

Curso de Redes Neuronales Artificiales (2000-2001). ETSETB- DEPARTAMENT D’ENGINYERIA ELECTRONICA. 

Introducción a los Agentes y Sistemas Multiagente. Llamas Bello César Departamento de Informática. Universidad de Valladolid. pp 10-25.







Sunday, November 25, 2012

Practica 4 Sistemas Multiagentes[Laboratorio]

Aunque no existe una definición formal y precisa de lo que es un agente, éstos son por lo general vistos como entidades inteligentes, equivalentes en términos computacionales a un proceso del sistema operativo, que existen dentro de cierto contexto o ambiente, y que se pueden comunicar a través de un mecanismo de comunicación interproceso, usualmente un sistema de red, utilizando protocolos de comunicación.En cierto modo, un sistema multiagentes es un sistema distribuido en el cual los nodos o elementos son sistemas de inteligencia artificial, o bien un sistema distribuido donde la conducta combinada de dichos elementos produce un resultado en conjunto inteligente.


Hay que notar que los agentes no son necesariamente inteligentes. Existen como en todo el resto del dominio de la inteligencia artificial, dos enfoques para construir sistemas multiagentes:

El enfoque formal o clásico, que consiste en dotar de los agentes de la mayor inteligencia posible utilizando descripciones formales del problema que resolver y de hacer reposar el funcionamiento del sistema en tales capacidades cognitivas. Usualmente la inteligencia es definida utilizando un sistema formal (por ejemplo, sistemas de inferencia lógica) para la descripción, raciocinio, inferencia de nuevo conocimiento y planificación de acciones a realizar en el medio ambiente.


El enfoque constructivista, que persigue la idea de brindarle inteligencia al conjunto de todos los agentes, para que a través de mecanismos ingeniosamente elaborados de interacción, el sistema mismo genere comportamiento inteligente que no necesariamente estaba planeado desde un principio o definido dentro de los agentes mismos (que pueden ser realmente simples). Este tipo de conducta es habitualmente llamado comportamiento emergente.




El estudio de los sistemas multiagentes está "interesado en el desarrollo y análisis de resoluciones a problemas sofisticados de IA y arquitecturas de control tanto para sistemas con un único agente como sistemas multiagentes”. Los temas de investigación en SMA’s son:
  • ingeniería de software orientado a agentes
  • creencias, deseos e intenciones (en inglés Beliefs, Desires and Intentions, BDI)
  • cooperación y coordinación
  • organización
  • comunicación
  • negociación
  • resolución de problemas distribuida
  • aprendizaje de multiagentes
  • comunidades científicas
  • fiabilidad y tolerancia a fallos

Para el caso de nuestra practica utilizamos el IDE de Netbeans para codificar en Java y el plugin de JADE, anteriormente utilizado en el reporte 4 de la clase de Sistemas Adaptativos, mismo que implementamos un pequeño ejemplo de como poder utilizar los sistemas multiagentes. Las clases utilizadas para el ejemplo fueron solo una denominada JADE con el cual inicializamos lo que es la interfaz gráfica de JADE, esto para mayor facilidad de lo que queríamos implementar, sin embargo una vez hecho el vídeo  la información se almacena en un archivo binario, a diferencia de codificarlo para un ejemplo automatizado. 





En este ejemplo para la practica, se mencionan al agente dos y tres que son de alguna manera los vendedores, quienes utilizan el medio para ofertar a nuestro comprador el libro que este busca, este código fue utilizado para inicializar la plataforma (GUI) de JADE, por lo cual implementamos un ejemplo manual, de como funcionan los sistemas multiagentes, sin embargo se puede mejorar, ya que es mas factible poder establecer limites, alcances y las metas a conseguir por cada uno de los agentes. Para el caso del vídeo se ejemplifica mas claramente como implementamos sobre este código  el uso de los diferentes agentes. 

Aclarando esto, se tiene entonces que el ejemplo utilizado es mas para fines de ver como interactuan un agente con los compradores potenciales y como pueden estos mantener entre estos una subasta ejemplificada, pero haciendo esto de manera manual, se puede implementar de manera automatizada, pero no podríamos para el caso del ejemplo, ver de donde provienen cada una de las propuestas económicas que cada agente realizaría  por lo que implementamos el ejemplo de forma manual y visualizando, a través de la clase jade.tool.dummy agent.Dummy agent, como podemos realizar una subasta del tipo que prefieramos.


La codificación para nuestra practica es breve, pero el ejemplo en el vídeo mostrado es sustancioso, para quienes se quieran atrever a realizar ejemplos mas complejos como el mostrado mas abajo por Victor Dark en su pagina personal de Youtube, donde nos muestra la interacción de agentes utilizando Twitter para determinar la información que recoge cada agente y como se interpreta para cada uno.




Bibliografía Consultada:

Introducción a los Agentes y Sistemas Multiagentes.  Llamas Bello César. Departamento de Informática Universidad de Valladolid.

Modelado de sistemas complejos mediante simulación basada en agentes y mediante dinámica de sistemas  Izquierdo, Luis R.; Galán, José M.;Santos, José I.;del Olmo, Ricardo (2008).  Empiria. Revista de Metodología de Ciencias Sociales 16. pp. 85-112.

Developing Multi-Agent Systems with JADE. Fabio Luigi Bellifemine, Giovanni Caire, Dominic Greenwood. Chapter 4.



Paginas visitadas para la realización de la practica:









Thursday, November 22, 2012

Thursday, November 15, 2012

Reporte 2 [CLASE]

Introducción
En el siguiente ejercicio se generó un programa que obtiene la distribución de grado y la densidad de una red compleja asignada y que es representada por su matriz de adyacencias correspondiente a la Unidad 2: "Algoritmos Adaptativos".


Desarrollo
Para calcular la densidad de la red y la distribución de grado se utilizo un método llamado Calculos( ) dentro de la clase Network.java. La parte más importante del codigo se encuentra obviamente aquí, ya que se evalúan los elementos de la matriz inicial (matriz[ ]) para sacar los valores de m y n y los nodos del grafo.


Lo primero que se calculan son el número de vértices, así como los nodos de la matriz para sacar lo valores de n y m y poder hacer el primer cálculo que es el de la densidad de la red.
for (int i=0; i < matriz.lenght;i++) {  
    for(int j=0;j < matriz.lenght;j++) {
 suma += matriz[i][j];
    }
 sumas[k] = suma;
 nodos += suma;
 k++;
 suma = 0;
 n = k; 
 m = nodos / 2; //
}

densidad = (float)(2*m) / (float)( n*(n-1) );


Una vez que se tienen ya los valores de n y m de la matriz se hace un conteo en los vértices de las repeticiones de número de nodos que hay en cada uno. Esto es para calcular el número de vértices con grado k y posteriormente encontrar la Distribución de grado.


También mediante un for se guardan los diferentes nodos que se encuentran en la matriz g[ ] ( != 0 ) y poder tener los grados de la red analizada.
 do {

    for (int r=0;r < n;r++) {
 if ( sumas[r] == aux ) {
            rep++;
     vertices[j] = sumas[r];
     repet[j] = rep;
     g[aux] = aux;
 }
    }

 aux++;
 rep=0;
 j++;

 }while(j <= n);
  
int aux1=0;
 for (int z=0;z < n;z++) {
     if (g[z] != 0 ) {
 grado[aux1] = g[z];
 aux1++;
     }
 }


Por último se imprimen los resultados obtenidos en un método independiente, llamado mostrarDatos( ) ahí mismo se realiza el cálculo de la distribución de grado antes de imprimirla para no guardarla en otro vector para cada grado.
 for(int r=0;r < 1;r++){System.out.println("\n");}
 System.out.println("\t\t    ----------------------");
 System.out.println("\t\t    ~Densidad de la Red~ "); 
 System.out.println("\t\t    ----------------------");

 System.out.println(" \tn = "+n);
 System.out.println(" \tm = "+m);
 System.out.println("\t\tDensidad = 2m / n(n-1)");
 System.out.println("\t\tDensidad = 2 x "+m+" / "+n+"("+n+"-1)");
 System.out.println("\t\tDensidad de la Red -> "+(2*m)+"/"+(n*(n-1))+" = "+densidad); 

 for(int r=0;r < 1;r++){System.out.println("\n");}
 System.out.println("\t\t--------------------------------");
 System.out.println("\t\t     ~Distribucion de Grado~    "); 
 System.out.println("\t\t--------------------------------");
 System.out.println("\t\t|| K || Vertices ||   Pr(k)   ||");
 int aux2 = 0;
 for(int v=0; v < n;v++){   
   if (repet[v] != 0 ) {
     int r = repet[v];
     float Pr = (float)r / n;
     System.out.println("\t\t   "+grado[aux2]+"\t    "+repet[v]+"\t   "+Pr);
     aux2++;
   }
 }


Para ver el código completo:

https://gist.github.com/4092835


A continuación se presenta la gráfica de la Distribución de Grado:




EXTRA: Se realizó la agrupación de la red mediante los grados calculados, se clasificó por color cada vértice dependiendo el grado de los subgrafos:




Video



Conclusiones
Se pretendió desde un principio adaptar este programa a cualquier red compleja que se pretenda analizar, teniendo la matriz de adyacencias en un archivo .txt, se presentaron algunas fallas al insertas los valores enteros en la matriz del programa y se optó que para fines prácticos por esta ocasión se insertaran los datos manualmente. Se harán las modificaciones correspondientes para adaptarlo a cualquier tamaño de red.

Tuesday, November 13, 2012

Reporte 1 [CLASE]

Introducción
En el siguiente ejercicio se desarrolló la simulación de un Ventilador Auto-ajustable a la temperatura del ambiente haciendo réplica del ejemplo visto en clase en la Unidad 1 "Algoritmos Adaptativos".


Desarrollo
El lenguaje que se utilizó fue JAVA y se utilizaron 2 Threads que se conectaban e interactuaban constantemente para mostrar el cambio de temperatura y estado del ventilador.


En la clase Reconocedor.java se fija una temperatura inicial de 25º C para comenzar la simulación e instanciamos el HiloTemperatura para que comience a evaluar la temperatura e irla ajustando dependiendo del estado actual del Ventilador. A continuación se presenta un fragmento del código

while(true) {

long end = System.currentTimeMillis(); //Se obtiene la hora del sistema en milisegundos (final)
long dif = end - start; //Se calcula el tiempo transcurrido entre la hora del sistema final e inicial

 if(dif >= 20000) { //Genera una temperatura aleatoria cada 20 segundos

  temp = ((genRand.nextInt(10000) % 30) + 17); 
                //Se genera un numero aleatorio entre 17 y 30
  temperatura = (double)temp; 
                // Se hace la conversion de tipo de dato entero a double
   
        /*Se pasan los valores de temperatura y velocidad en la clase Hilo Temperatura*/

  hiloTemp.setTemperatura(temperatura); 
  hiloTemp.setVelocidad(velocidad);

  start = System.currentTimeMillis();

  if (temperatura > 24) {
   estadoVentilador = true;
   setEstado(estadoVentilador);
    
  } else {
   estadoVentilador = false;
   setEstado(estadoVentilador);
  } 

  velocidad = hiloTemp.getVelocidad();
  temperatura = hiloTemp.getTemperatura(); 

 }
 else {
  if (temperatura > 24) {
   estadoVentilador = true;
   setEstado(estadoVentilador);
   
  } else {
   estadoVentilador = false;
   setEstado(estadoVentilador);
  } 
   
 velocidad = hiloTemp.getVelocidad();
 temperatura = hiloTemp.getTemperatura(); 

 } 
 

 for(int r=0;r<20;r++){System.out.println("\n");}
  System.out.println("\t\t----------------------------------");
  System.out.println("\t\t~Sistema Control de un Ventilador~"); 
  System.out.println("\t\t----------------------------------");

  System.out.println("\n\t\t\t~Estado del Ventilador~");
  System.out.println("\n\tTemperatura Ambiental -> "+temperatura+" ºC");
  System.out.println("\n\tVelocidad -> "+velocidad);
  System.out.println("\n\tEstado -> "+state); 

  temperatura = hiloTemp.getTemperatura();
  hiloTemp.setTemperatura(temperatura); 
   
Thread.sleep(5000);
} //Fin del while



En la clase HiloTemperatura.java se hacen validaciones para ajustar la velocidad del ventilador y reducir o aumentar la temperatura dependiendo del estado actual del mismo.


Si el ventilador se encuentra prendido, dependiendo la velocidad del mismo, irá bajando la temperatura del ambiente en un intervalo de 500 milisegundos del hilo de la clase Ventilador, es decir, que para fines prácticos, cada 500 milisegundos disminuirá la temperatura del Ventilador dependiendo de la velocidad del mismo y el estado del Sistema. A continuación se presenta un fragmento del código:


while(true) {
/*Se ira reduciendo la temperatura ambiental dependiendo de la velocidad del ventilador cada 500 milisegundos*/  
  
 if ( (temperatura >= 25) && (temperatura <= 28) ) {
 velocidad = 1;
 hiloVent.setVelocidad(velocidad);
   
  temperatura = temperatura - 0.10;
  hiloVent.setTemperatura(temperatura);
   
 } 

 else if( (temperatura >= 29) && (temperatura <=34) ) {
 velocidad = 2;
 hiloVent.setVelocidad(velocidad);
 
  temperatura = temperatura - 0.05;
  hiloVent.setTemperatura(temperatura);
    
 } 

 else if( temperatura >= 35 ) {
 velocidad = 3;
 hiloVent.setVelocidad(velocidad);

  temperatura = temperatura - 0.02;
  hiloVent.setTemperatura(temperatura);
    
 } 

 else if (temperatura <= 24) {
 velocidad = 0;
 hiloVent.setVelocidad(velocidad);

  temperatura = temperatura + 0.12;
  hiloVent.setTemperatura(temperatura);
    
 }

Thread.sleep(500);
}


Para ver el código completo:

http://gist.github.com/4067869


Video


Conclusiones
Una vez visto los resultados de la aplicación se observa que hay un ligero retardo en el ajuste de la velocidad en pantalla, pero aún así se ajusta y se va aumentando o disminuyendo dependiendo de la velocidad. Para fines de simulación, cada 20 segundos se cambia la temperatura del ambiente aleatoriamente para poder observar en las corridas diferentes ajustes.

Sunday, November 11, 2012

Reporte 4 [Clase]

Sistemas Multiagente

Para realizar este reporte se nos dieron 4 opciones JADE, SPADE, Madkit y Robocup, de las cuales se escogió hacerlo sobre uno de los lenguajes que mas llaman la atención por la versatilidad que presenta y su aplicación simple, esto debido a que es multiplataforma y existe en la mayoría de los equipos un JRE para poder correr dichas aplicaciones generadas en Java sin necesidad de instalar complementos adicionales (dependiendo el programador ya incluiría en su instalación los paquetes que requiera adicionales) .

JADE (Java Agent DEvelopment Framework) es un marco de trabajo aplicado plenamente en el lenguaje Java. Simplifica la implementación de sistemas multi-agente a través de un middleware que cumple con las especificaciones FIPA y a través de un conjunto de herramientas gráficas que soportan la depuración y fases de despliegue. La plataforma de agentes pueden ser distribuidos a través de máquinas (que ni siquiera necesitan compartir el mismo sistema operativo) y la configuración se puede controlar a través de una interfaz gráfica de usuario remoto . 

La configuración se puede cambiar incluso en tiempo de ejecución moviendo agentes de una máquina a otra, como y cuando sea necesario. JADE está completamente implementada en lenguaje Java y la exigencia mínima del sistema es la versión 1.4 de Java (el entorno de tiempo de ejecución o el JDK).

JADE es software libre y se distribuye por Telecom Italia , el titular del derecho de autor, en el software de código abierto bajo los términos de la LGPL (Lesser General Public License Version 2). Desde mayo de 2003, una Asociación JADE ha creado supervisiones para la gestión del proyecto JADE. Actualmente lista 5 miembros: Telecom Italia , Motorola , Whitestein Technologies AG, GmbH Profactor y France Telecom R & D .

JADE tiene una extensión denominada WADE (Workflows and Agents Development Environment) que es un sistema de workflow que permite crear procesos mediante un editor gráfico llamado WOLF.

El componente clave de la plataforma WADE es la clase Workflow Engine Agent que extiende la clase Agent básica de la biblioteca JADE incorporada en el flujo de trabajo,  es un motor pequeño y ligero. Además de los comportamientos JADE normales, un Workflow Engine Agent es por lo tanto capaz de ejecutar flujos de trabajo representadas de acuerdo con un formalismo WADE específico. Este formalismo se basa en el lenguaje Java: un flujo de trabajo WADE es en realidad una clase Java con una estructura bien definida. Este enfoque permite combinar la expresividad de la metáfora del flujo de trabajo con el poder de un lenguaje de programación como Java, y permite el uso de flujos de trabajo para la definición de sistema de lógica interna.


En principio WADE apoya el estilo de programación "editor de textos - programación" en el sentido de que no hay cosas ocultas que los desarrolladores no pueden controlar. Sin embargo, sobre todo teniendo en cuenta que una de las ventajas principales del enfoque de flujo de trabajo es la posibilidad de representar los procesos en una forma gráfica amigable, WADE viene con un entorno de desarrollo llamado WOLF que facilita la creación de WADE  o una aplicación basada en WADE. WOLF es un plug-in de Eclipse, y como consecuencia permite a los desarrolladores aprovechar WADE con todo el poder de la IDE de Eclipse más características adicionales específicas de WAD.


Ejemplo tomado del tutorial de WADE, Fracción de código

... 
public class AssemblerAgent extends WorkflowEngineAgent { 
  private AssemblerAgentGui myGui; 
  private DispatchingCapabilities dc = new DispatchingCapabilities(); 
  private List searcherAgents = new ArrayList();  
  private int index = 0; 
  /**
   * Agent initialization
   */

  protected void agentSpecificSetup() throws AgentInitializationException { 
    super.agentSpecificSetup(); 
// Create and show the gui
    myGui = new AssemblerAgentGui(this); 
    myGui.initGui(); 
    myGui.setVisible(true); 
    // Initialize the DispatchingCapabilities instance used 
    // to launch workflows
    dc.init(this);

    // Subscribe to the DF to keep the searchers list up to date
    ServiceDescription sd = new ServiceDescription(); 
    sd.setType("Searcher Agent"); 
    DFAgentDescription dfTemplate = new DFAgentDescription(); 
    dfTemplate.addServices(sd); 
    SearchConstraints sc = new SearchConstraints(); 
    sc.setMaxResults(new Long(-1)); 
    ACLMessage subscribe = DFService.createSubscriptionMessage( 
                           this,  
                           getDefaultDF(),  
                           dfTemplate,  
                           sc); 
    addBehaviour(new SubscriptionInitiator(this, subscribe) { 
      ... 
    } ); 
  } 
  ... 
  /** 
   * Select a suitable SearcherAgent 
   */ 



  public AID getSearcherAgent() { 
    if (searcherAgents.isEmpty()) { 
      throw new RuntimeException("No SearcherAgent available"); 
    } 
    if (index >=searcherAgents.size()) { 
      index = 0; 
    } 
    return (AID) searcherAgents.get(index++); 
  } 
  /**
   * The method invoked by the GUI when the user requests
   * the assembling of a toy
   */
  void assembleToy(final String type) { 
    ... 
  } 



Finalmente obtenemos de manera simple y llana la salida de este código, el cual posteriormente implementará la interfaz gráfica para definir las tareas visuales que se realizan.


El orden de las imágenes no necesariamente cumple con lo especificado en el código o en el reporte de cada uno de los pasos a seguir cuando utilizamos el tutorial; sin embargo es muy claro en la forma de trabajo que debemos seguir para obtener un resultado favorable; también es un hecho, el tutorial esta orientado a un ejemplo especifico, si nosotros deseamos interactuar con WADE a través de JADE podemos implementar por mencionar un ejemplo, la practica 4 utilizando estas herramientas si nuestro interés es aplicar el lenguaje Java en su conjunto con estas dos herramientas indispensables para un resultado sobresaliente en una aplicación sencilla.


También la empresa Oracle presenta una herramienta interesante que trabaja de manera similar, mas poderosa y mas orientada a las empresas de mayor peso, dejo aquí un demo de esa herramienta y como podemos, por mencionar el ejemplo de subastas, hacer una pequeña aplicación de esa subasta mediante JDeveloper. Les dejo este Link para que visiten y visualicen en tiempo real como trabaja esta herramienta. Hay opciones de paga que también permiten obtener un trabajo de mayor calidad y menores contratiempos basados en estas herramientas que se presentan en este reporte.

Video Demostrativo



Vídeo 1 en Youtube sobre el uso de Jade y Wade en Android.


Vídeo 2 Ejemplo sin utilizar la Interfaz Gráfica, solo a través de consola.


Vídeo 3 Ejemplo interactuando con la GUI de JADE directamente.


Paginas visitadas

http://jade.tilab.com/

http://jade.tilab.com/wade/index.html

Videos utilizados incrustados en este reporte desde su ubicación original para no afectar a sus autores. Videos personales incluidos en este reporte, utilizando la salida en consola para el reporte.

Imágenes utilizadas en este reporte:

E X P L O I T I N G I N T E R A C T I V E  
W O R K F L O W S  O N  A N D R O I D D E V I C E S
http://jade.tilab.com/wade/doc/tutorial/ExploitingInteractiveWorkflowsOnAndroidDevices.pdf


WA D E  T U TO R I A L  
DEFINING AGENT TASKS AS WORKFLOWS

http://jade.tilab.com/wade/doc/tutorial/WADE-Tutorial.pdf


Tuesday, October 30, 2012

Entrega 3 [Proyecto Clase]

Control de un Sistema mediante el Reconocimiento de Voz

Introducción

Durante las últimas décadas se ha estudiado la posibilidad de desarrollar interfaces hombre-computador controlados por voz para sustituir  en ciertas aplicaciones a las interfaces tradicionales basadas en teclados o ratones. El Reconocimiento Automático de Voz es un campo de investigación de creciente relevancia que día a día gana mas partidarios.

Los reconocedores actuales manejan cada vez vocabularios más grandes, logran menores tasas de error de reconocimiento y menores tiempos de procesamiento gracias al uso de algoritmos mas eficientes, a la aplicación de equipos más potentes y económicos, y al aumento de la complejidad de estos sistemas, al emplearse modelados más sofisticados y refinados. No obstante, a pesar de los grandes avances realizados, se está todavía muy lejos de un sistema de reconocimiento automático de voz universal que funcione bien en cualquier aplicación a la que sea destinado.

Hoy en día la mayoría de los sistemas reconocedores en funcionamiento, se basan en la técnica de modelos ocultos de Markov, debido a que requieren menos memoria física, ofrecen menor tiempo de respuesta y una menor tasa de error con respecto a otras herramientas matemáticas utilizadas en reconocimiento de patrones. En este caso el reconocimiento es basado en la comparación de patrones de referencia denominados modelos con los vectores de características generados para la palabra a reconocer.

Resumen del Proyecto

La primer idea de nuestro proyecto se basaba en la implementación de un sistema de reconocimiento de voz desarrollado en Python para GNOME 3 que controlara algunas acciones de las acciones de un Sistema Operativo Linux.

Ya conforme la marcha, se empiezan a surgir nuevas ideas en Java, inclusive cambiar prácticamente el giro del proyecto a ser implementado en algún dispositivo móvil utilizando la parte adaptativa que sería el auto-ajuste de ciertos parámetros siguiendo una metodología de reconocimiento de patrones.

Hasta el momento se logra, gracias también a la práctica 3 del Laboratorio, solamente hacer el reconocimiento de voz gracias a la libreria TalkingJava SDK de Cloudgarden.

Avance del Proyecto

Se ha conseguido realizar el reconocimiento de ciertas palabras mediante un diccionario que cumple con JSGF, el cual es un conjunto de convenciones para la gramática en el reconocimiento de Voz.

Entre los problemas que se han suscitado está al utilizar el micrófono integrado con la webcam de una laptop y con el ruido del entorno se tarda en reconocer y confunde ciertas palabras similares.

A continuación se presenta un fragmento del programa:

  
public class Palabras extends ResultAdapter {
  static Recognizer rec;
  String Palabra;

  public void reconocerPalabra(ResultEvent e){
 try {
  Result res = (Result)(e.getSource());
  ResultToken tokens[] = res.getBestTokens();
  String Frase[]= new String[1];
  Frase[0]="";

  for (int i=0; i < tokens.length; i++){
   Palabra = tokens[i].getSpokenText();
   Frase[0]+=Palabra+" "; 
   System.out.print(Palabra + " ");
  }
  System.out.println();
  if (Palabra.equals("Fin")) {
   rec.deallocate();
   System.out.println(Frase[0]);
   System.exit(0);
  }
  else if(Palabra.equals("Adelante")){
              System.out.println("ADELANTE");
  } 

  else if(Palabra.equals("Atras")){
   System.out.println("ATRAS");
  } 

  else {
   getPalabra();
   rec.suspend();
    rec.resume();
  }
 }catch(Exception ex){
 }
  }

  public String getPalabra(){
 return Palabra;
  }
}

Recursos y Herramientas


CloudGarden ha producido una plena aplicación de la API de Sun Java Speech para las plataformas Windows, lo que permite una amplia gama de SAPI4 y SAPI5 compatible con Text-To-Speech y Reconocimiento del Habla a ser programadas usando la API estándar de Java Speech.

El formato de la gramática JSpeech (JSGF) es una plataforma independiente en representación textual de gramáticas para su uso en el reconocimiento de voz. Es utilizado por los reconocedores de voz para determinar lo que el reconocedor debe escuchar, y así describir los enunciados que un usuario puede decir.
  • TalkingJava SDK with Java Speech API implementation Current Version 1.7.0, el cual es un conjunto de convenciones para la gramática en el reconocimiento de Voz.
  • http://www.sicuma.uma.es/sicuma/independientes/argentina08/Liliana/JSAPI.htm
  • http://www.w3.org/TR/jsgf/