Tuesday, February 5, 2013

Práctica 1 - Semáforos [Laboratorio]

Objetivo:
Desarrollar un sistema adaptativo que simule un sistema de semaforos interactuando entre si, para coordinar el trafico en un cruze de avenidas.

Explicación del cruce:
En los semáforos 'A', 'B', 'C' y 'D' se incluyen los estados 'Verde', 'Amarillo' y 'Rojo'; los semáforos 'E', 'F', 'G' y 'H' representan la 'Flecha', este estado le dice al conductor que avance mientras la 'Flecha' este encendida, y mientras esta este apagada, el conductor se detendrá.
El cruce cuenta con sensores de peso en cada calle, por lo que el tiempo de los semáforos se adaptara de acuerdo a la afluencia de automóviles. La cantidad de automóviles se verificara individualmente en cada 'semáforo' justo antes del inicio de su estado 'Verde', teniendo en cuenta también, la afluencia de automóviles en otros semáforos.
Este cruce esta catalogado como 'Peligroso' por lo que las 'vueltas con precaución (a la derecha)' están prohibidas, anunciándole esto a los conductores con la leyenda 'Espere su Luz'


Diagrama del cruce:

Funcionamiento:
Al inicio del programa, 'C' y 'G' estarán en verde, mientras que todos los demás estarán en rojo; este estado se mantendrá 30 segundos.
Al termino de este, 'G' se apagara, para dar lugar a 'A' a encenderse, mientras 'A' y 'C' esten en verde, 'B' y 'D' tienen que estar en rojo. Dicho estado se mantendrá por 1 minuto.
A continuación, 'C' se pondrá en rojo, dando lugar a 'E' a encenderse; dicho estado durara 30 segundos.
Después de esto, 'A' y 'E' se pondrán en rojo para que 'B' y 'F' puedan encenderse; este estado durara 30 segundos.
Continuando con el apagado de 'F' para que 'D' pueda encenderse, dejando así, encendidos en verde solamente a 'B' y 'D'; dicho estado durara 1 minuto.
Para terminar, 'B' se apagara y 'H' se encenderá; quedando así únicamente 'D' y 'H' encendidos; dicho estado durara 30 segundos.
Una vez que haya terminado este ciclo, comenzara de nuevo, pero cada semáforo verificara la cantidad de autos a transitar, antes  de encenderse en Verde, con el objetivo de modificar su duración, y permitir el paso de mayor cantidad de vehículos, desahogando así la avenida.

Condiciones del cruce representadas en este grafo:


  • Cuando 'A' este en verde, solamente 'E' y 'C' pueden estar en verde al mismo tiempo.
  • Cuando 'B' este en verde, solamente 'D' y 'F' pueden estar en verde al mismo tiempo.
  • Cuando 'C' este en verde, solamente 'A' y 'G' pueden estar en verde al mismo tiempo.
  • Cuando 'D' este en verde, solamente 'B' y 'H' pueden estar en verde al mismo tiempo.
  • Cuando 'E' este en verde, solamente 'A' y 'G' pueden estar en verde al mismo tiempo.
  • Cuando 'G' este en verde, solamente 'C' y 'E' pueden estar en verde al mismo tiempo.
  • Cuando 'H' este en verde, solamente 'D' y 'F' pueden estar en verde al mismo tiempo.

Esta es la matriz en el que se demuestra en base a como da el cruce



a
b
c
d
e
f
g
h
1
0
0
1
0
0
0
1
0
2
1
0
1
0
0
0
0
0
3
1
0
0
0
1
0
0
0
4
0
1
0
0
0
1
0
0
5
0
1
0
1
0
0
0
0
6
0
0
0
1
0
0
0
1

Los 1's son los carriles en verde.

Codigo:

El codigo esta hecho en Lenguaje C, esta realizado lo mas sencillo pero este simula que estan n carros en tales carriles, se utilizo funciones de espera, de tiempo y de generar cifras aleatorias para la realizacion de el semaforo.

Los siguientes modulos realizados para el programa son:

Modulo Semaforo:

Este codigo es el motor, por asi decirlo del programa, ya que en ella se imprime y se simula el paso de los carros en los carriles, pero muestra el numero de carros en cada carril.
int semaforo()
{
 int i,j;
    do
 {
  for(i=0;i<6;i++)
  {
   for(j=0;j<16;j++)
   {
    if(esto[i][0]==1&&car1>0) car1--;
     if(esto[i][1]==1&&car2>0) car2--;
     if(esto[i][2]==1&&car3>0) car3--;
     if(esto[i][3]==1&&car4>0) car4--;
     if(esto[i][4]==1&&car5>0) car5--;
     if(esto[i][5]==1&&car6>0) car6--;
     if(esto[i][6]==1&&car7>0) car7--;
     if(esto[i][7]==1&&car8>0) car8--;
    printf("\nCarriles en Semaforo en Verde: ");
     carriltr(esto[i][0],esto[i][1],esto[i][2],
esto[i][3],esto[i][4],esto[i][5],esto[i][6],esto[i][7]);
    printf("\nEsperen su luz: ");
     carriltr2(esto[i][0],esto[i][1],esto[i][2],
esto[i][3],esto[i][4],esto[i][5],esto[i][6],esto[i][7]);
     printf("\n\nCarril A: %d Carril B: %d \n",
car1,car2);
     printf("Carril C: %d Carril D: %d \n",car3,car4);
     printf("Carril E: %d Carril F: %d \n",car5,car6);
     printf("Carril G: %d Carril H: %d \n\n\n",car7,
car8);
          Sleep(500);
          system("cls");
   }
   car1=rand()%8 + car1;
      car2=rand()%8 + car2;
      car3=rand()%8 + car3;
      car4=rand()%8 + car4;
      car5=rand()%8 + car5;
      car6=rand()%8 + car6;
      car7=rand()%8 + car7;
      car8=rand()%8 + car8;
  }
 }   
    while(1);                 
    return 0;            
}
Modulos CarrilVerde y CarrilEspera:

En realidad estos son para indicar cuales carriles estan pasando y quienes estan esperando.

int carriltr(ca,cv,c2,cdd,ce,cf,cg,ch)
{
   if(ca==1) printf("A ");
    if(cv==1) printf("B ");
    if(c2==1) printf("C ");
    if(cdd==1) printf("D ");
    if(ce==1) printf("E ");
    if(cf==1) printf("F ");
    if(cg==1) printf("G ");
    if(ch==1) printf("H ");
    return 0;
}

int carriltr2(ca,cv,c2,cdd,ce,cf,cg,ch)
{
   if(ca==0) printf("A ");
    if(cv==0) printf("B ");
    if(c2==0) printf("C ");
    if(cdd==0) printf("D ");
    if(ce==0) printf("E ");
    if(cf==0) printf("F ");
    if(cg==0) printf("G ");
    if(ch==0) printf("H ");
    return 0;
}
Modulo Main

Es el modulo principal de arranque del programa, en ella se inicializa el numero de carros en cada carril.

int main()
{
    srand(time(NULL)); 
    printf("Semaforo en C\n\nEfren Morales\nDaniel Cruz\nAdrian\n\n");
    printf("\nPresione para iniciar");
    system("pause >nul");
    system("cls");
    car1=rand()%16;
    car2=rand()%16;
    car3=rand()%16;
    car4=rand()%16;
    car5=rand()%16;
    car6=rand()%16;
    car7=rand()%16;
    car8=rand()%16;
    semaforo();
    return 0;
}

Codigo Completo.


#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include <windows.h>

int carros[100][7];
int num,n,carril;
int car1,car2,car3,car4,car5,car6,car7,car8;
int ca,cv,c2,cdd,ce,cf,cg,ch;
int esto[6][8] = {0,0,1,0,0,0,1,0,1,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1};

int carriltr(ca,cv,c2,cdd,ce,cf,cg,ch)
{
   if(ca==1) printf("A ");
    if(cv==1) printf("B ");
    if(c2==1) printf("C ");
    if(cdd==1) printf("D ");
    if(ce==1) printf("E ");
    if(cf==1) printf("F ");
    if(cg==1) printf("G ");
    if(ch==1) printf("H ");
    return 0;
}

int carriltr2(ca,cv,c2,cdd,ce,cf,cg,ch)
{
   if(ca==0) printf("A ");
    if(cv==0) printf("B ");
    if(c2==0) printf("C ");
    if(cdd==0) printf("D ");
    if(ce==0) printf("E ");
    if(cf==0) printf("F ");
    if(cg==0) printf("G ");
    if(ch==0) printf("H ");
    return 0;
}

int semaforo()
{
 int i,j;
    do
 {
  for(i=0;i<6;i++)
  {
   for(j=0;j<16;j++)
   {
    if(esto[i][0]==1&&car1>0) car1--;
     if(esto[i][1]==1&&car2>0) car2--;
     if(esto[i][2]==1&&car3>0) car3--;
     if(esto[i][3]==1&&car4>0) car4--;
     if(esto[i][4]==1&&car5>0) car5--;
     if(esto[i][5]==1&&car6>0) car6--;
     if(esto[i][6]==1&&car7>0) car7--;
     if(esto[i][7]==1&&car8>0) car8--;
    printf("\nCarriles en Semaforo en Verde: ");
     carriltr(esto[i][0],esto[i][1],esto[i][2],
esto[i][3],esto[i][4],esto[i][5],esto[i][6],esto[i][7]);
    printf("\nEsperen su luz: ");
     carriltr2(esto[i][0],esto[i][1],esto[i][2],
esto[i][3],esto[i][4],esto[i][5],esto[i][6],esto[i][7]);
     printf("\n\nCarril A: %d Carril B: %d \n",
car1,car2);
     printf("Carril C: %d Carril D: %d \n",car3,car4);
     printf("Carril E: %d Carril F: %d \n",car5,car6);
     printf("Carril G: %d Carril H: %d \n\n\n",car7,
car8);
          Sleep(500);
          system("cls");
   }
   car1=rand()%8 + car1;
      car2=rand()%8 + car2;
      car3=rand()%8 + car3;
      car4=rand()%8 + car4;
      car5=rand()%8 + car5;
      car6=rand()%8 + car6;
      car7=rand()%8 + car7;
      car8=rand()%8 + car8;
  }
 }   
    while(1);                 
    return 0;            
}

int main()
{
    srand(time(NULL)); 
    printf("Semaforo en C\n\nEfren Morales\nDaniel Cruz\nAdrian\n\n");
    printf("\nPresione para iniciar");
    system("pause >nul");
    system("cls");
    car1=rand()%16;
    car2=rand()%16;
    car3=rand()%16;
    car4=rand()%16;
    car5=rand()%16;
    car6=rand()%16;
    car7=rand()%16;
    car8=rand()%16;
    semaforo();
    return 0;
}

Demostracion:

 

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