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.
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++;
}
}
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.
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);
}
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.
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
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 implementationCurrent Version 1.7.0, el cual es un conjunto de convenciones para la gramática en el reconocimiento de Voz.
Con un paradigma convencional de programación en ingeniería del software, el objetivo del programador es modelar matemáticamente (con distintos grados de formalismo) el problema en cuestión y posteriormente formular una solución (programa) mediante un algoritmo codificado que tenga una serie de propiedades que permitan resolver dicho problema. En este sentido, el diseño de la red tiene menos que ver con cuestiones como los flujos de datos y la detección de condiciones, y más que ver con cuestiones tales como la selección del modelo de red, la de las variables a incorporar y el pre procesamiento de la información que formará el conjunto de entrenamiento. Asimismo, el proceso por el que los parámetros de la red se adecuan a la resolución de cada problema no se denomina genéricamente programación sino que se suele denominar entrenamiento neuronal.
La mayoría de los científicos coinciden en que una RNA es muy diferente en términos de estructura de un cerebro animal. Al igual que el cerebro, una RNA se compone de un conjunto masivamente paralelo de unidades de proceso muy simples y es en las conexiones entre estas unidades donde reside la inteligencia de la red. Sin embargo, en términos de escala, un cerebro es muchísimo mayor que cualquier RNA creada hasta la actualidad, y las neuronas artificiales también son más simples que su contrapartida animal. Biológicamente, un cerebro aprende mediante la reorganización de las conexiones sinápticas entre las neuronas que lo componen. De la misma manera, las RNA tienen un gran número de procesadores virtuales interconectados que de forma simplificada simulan la funcionalidad de las neuronas biológicas. En esta simulación, la reorganización de las conexiones sinápticas biológicas se modela mediante un mecanismo de pesos, que son ajustados durante la fase de aprendizaje. En una RNA entrenada, el conjunto de los pesos determina el conocimiento de esa RNA y tiene la propiedad de resolver el problema para el que la RNA ha sido entrenada.
Las redes neuronales artificiales (RNA) tienen muchas ventajas debido a que están basadas en la estructura del sistema nervioso, principalmente el cerebro.
Aprendizaje: Las RNA tienen la habilidad de aprender mediante una etapa que se llama etapa de aprendizaje. Esta consiste en proporcionar a la RNA datos como entrada a su vez que se le indica cuál es la salida (respuesta) esperada.
Auto organización: Una RNA crea su propia representación de la información en su interior, descargando al usuario de esto.
Tolerancia a fallos: Debido a que una RNA almacena la información de forma redundante, ésta puede seguir respondiendo de manera aceptable aun si se daña parcialmente.
Flexibilidad: Una RNA puede manejar cambios no importantes en la información de entrada, como señales con ruido u otros cambios en la entrada (por ejemplo si la información de entrada es la imagen de un objeto, la respuesta correspondiente no sufre cambios si la imagen cambia un poco su brillo o el objeto cambia ligeramente).
Tiempo real: La estructura de una RNA es paralela, por lo cual si esto es implementado con computadoras o en dispositivos electrónicos especiales, se pueden obtener respuestas en tiempo real.
Objetivo
Con esta practica queremos conocer las implementaciones del reconocimiento de patrones mediante la aplicación de las redes neuronales en herramientas de software con entrenamiento de perceptrones que ayuden a las personas en sus deficiencias genéticas o accidentales con la finalidad de avanzar tecnológicamente. Nos proporciona herramientas para nuestra formación profesional, y la manera en que podemos plantearnos soluciones a problemas complejos que nos encontremos en el camino de nuestras labores cotidianas como desarrolladores o dueños de empresas enfocadas a dar soluciones de software enfocado a estas habilidades medicas
Justificación
La elaboración de la presente práctica es para conocer la funcionalidad de los perceptrones y como podemos entrenarlos para un objetivo especifico o bien para determinadas acciones dentro de un todo. Nos ayuda a entender como funcionan las cosas en la vida real y como estas observaciones gracias a grandes investigadores han ido saliendo a la luz con ayuda de las diferentes ciencias aplicadas para poder darle al ser humano una visión mas amplia de su entorno mediante un espacio virtual
Bajo ese precepto la practica que implementamos ocupa realizar una cadena de "neuronas" artificiales para el reconocimiento de patrones, y que pretende retroalimentar lo anteriormente mencionado sobre la red neuronal y una de sus posibles aplicaciones
La clase Main
intmain(int argc, constchar *argv[]) {
Mat frame;
CvCapture* capture;
//aqui indicamos las validaciones para dar por enterado cuando tenemos errores en la identificaciónif(!fc.load(fcn)) {
std::cout << "Error cargando cascada de clasificacion..." << std::endl;
return -1;
}
//o bien pasamos los valores que la camara esta tomando en ese momento para que nuestras neuronas
capture = cvCaptureFromCAM(-1);//artificiales puedan posteriormente reconocer este patron de valoresif(capture) { //mismos que se tendran en el archivo xml, y podran compararse posteriormente, si el while(true) {//individuo volviera a pasar frente a la camara la proxima ocasión, las neuronas podran
frame = cvQueryFrame(capture);//recordar los valores de los rasgos de las caras que pasaron//frente a la camara de manera que sera mas factible poder resolver mas rapidamente el reconocimientoif(!frame.empty())//facial de la persona reconocida.
reconoceme(frame);
else {
std::cout << "Error al capturar video..." << std::endl;//error de salida en el caso de tener algunbreak;//inconveniente para almacenar o guardar la informacion de la cara de la persona.
}
int q = waitKey(10);//simplemente al terminar podremos presionar la tecla q o Q para salirif((char)q == 'q' || (char)q == 'Q')//segun sea el caso, por lo que es bastante simple el break;// manejo de este programa.
}
}
return 0;
}
La clase reconoceme es donde ocurre toda la lógica neuronal
void reconoceme(Mat frame) {
Mat frame_gray;// en este punto generamos un marco de trabajo
std::vector<Rect> faces;//utilizando vectores para ello, es decir indicara en un cuadro la cara //localizada en el marco de la camara manejada como una matriz
cvtColor(frame, frame_gray, CV_BGR2GRAY);//de esta manera es mas simple localizar rasgos especificos
equalizeHist(frame_gray, frame_gray);//de las personas localizadas en el rango de percepcion de la
fc.detectMultiScale(frame_gray, faces, 1.1, 2, 0, Size(80, 80));//camara, razón por la que se ajustan// los parametros para que nuestras neuronas artificiales no cometan errores, o bien estos sean minimosfor(int i = 0; i < faces.size(); i++) { //aqui el programa podra determinar si tiene en frente uno
Mat faceROI = frame_gray(faces[i]);// o mas caras de personas en el rango visual de la camara
Point pt1(faces[i].x, faces[i].y);//por lo que podra implementar el reconocimiento de las personas
Point pt2(faces[i].x + faces[i].width, faces[i].y + faces[i].height);//alrededor de la camara, lo hará
rectangle(frame, pt1, pt2, Scalar(0, 0, 0), 10, 8, 0);// tantas veces como le sean necesarias
}
Point salir(5, 35);
putText(frame, "Presiona 'Q' para salir...", salir, 1, 1.5, Scalar(0, 0, 0), 2, 8, 0);
imshow(title, frame);
}
Finalmente nuestra base de información, es decir, las "neuronas", aquí es de donde son llamadas para realizar la interpretación enviada por la cámara y llamada por la clase reconoceme para implementar los análisis de lo observado
string title = "Deteccion de patrones practicando con redes neuronales";
String fcn = "reconoceme.xml";//hacemos referencia a un documento xml el cual contiene
CascadeClassifier fc;//cada una de las "neuronas"
Resultados
A la izquierda ejemplo localizado en la red, a la derecha foto de lo que se implemento. Detalles de resolución y diseño es lo que aplicaría en el caso de querer mejorar el diseño de la interfaz gráfica.
Vídeo Generado para visualizar la aplicación de el reconocimiento facial
Bibliografía Consultada
C. Aldrich and J. S. J. van Deventer.Comparison of different artificial neural nets for the detection and location of gross errors in process systems. Industrial & Engineering Chemistry Research, 34(1):216-224,1995.
C. M. Bishop. Neural Networks for Pattern Recognition. Oxford University Press, USA, 1995.
C. M. Bishop. Pattern recognition and machine learning. Springer, 2006 (Online service).
G. J. Bowden, G. C. Dandy, and H. R. Maier. Data transformation for neural network models in water resources applications. Journal of Hydroinformatics, 5(4):245-258, 2003.
M. Brown and C. Harris. Neurofuzzy adaptive modelling and control Prentice Hall, 1995.
J. A. Freeman and D. M. Skapura. Neural Networks: Algorithms, Applications, and Programming Techniques. Addison-Wesley, 1991.
J. R. Hilera and V. J. Martinez. Redes neuronales artificiales. Fundamentos, modelos y aplicaciones. Addison-Wesley Iberoamericana S.A, Madrid, 1995.
J. C. Hoskins and D. M. Himmelblau. Process control via artificial neural networks and reinforcement learning. Computers & chemical engineering, 16(4):241-251, 1992.
Imágenes de http://en.wikipedia.org/wiki/
Imágenes personales incluidas en el reporte generadas por captura de pantalla, para poder obtener lo que se observa en el preciso momento de la rutina del programa.
Información de "neuronas artificiales" con ayuda de Ibarra Cano
Existen problemas de optimización combinatoria complejos en diversos campos
como la economía, el comercio, la ingeniería, la industria o la medicina. Sin embargo, a menudo estos problemas son muy difíciles de resolver en la práctica. El estudio de esta dificultad inherente para resolver dichos problemas tiene cabida en el campo de la teoría de las Ciencias de la Computación, ya que muchos de ellos pertenecen a la clase de problemas NP-duros, lo que significa que no existe un algoritmo conocido que los resuelva en un tiempo polinomial
Las metaheurísticas incorporan conceptos de muchos y diversos campos como la genética, la biología, la inteligencia artificial, las matemáticas, la física y la neurología, entre otras. Algunos ejemplos de metaheurísticas son: Enfriamiento simulado [1, 64], búsqueda tabú [49], búsqueda local iterativa (“iterated local search”)[66], algoritmos de búsqueda local con vecindario variable (“variable neighborhood search”)[57], GRASP (“greedy randomized adaptative search procedures”) [39, 40] y algoritmos evolutivos [5, 6, 60]. Una metaheurística relativamente reciente es la Optimización basada en Colonias de Hormigas (OCH)(“Ant Colony Optimization”, ACO en inglés), la cual se inspira en el comportamiento que rige a las hormigas de diversas especies para encontrar los caminos más cortos entre las fuentes de comida y el hormiguero.
Las hormigas son insectos sociales que viven en colonias y que, debido a su colaboración mutua, son capaces de mostrar comportamientos complejos y realizar tareas difíciles desde el punto de vista de una hormiga individual. Un aspecto interesante del comportamiento de muchas especies de hormigas es su habilidad para
encontrar los caminos más cortos entre su hormiguero y las fuentes de alimento.
Mientras que se mueven entre el hormiguero y la fuente de alimento, algunas especies de hormigas depositan una sustancia química denominada feromona (una sustancia que puede “olerse”). Si no se encuentra ningún rastro de feromona, las hormigas se mueven de manera básicamente aleatoria, pero cuando existe feromona depositada, tienen mayor tendencia a seguir el rastro
Pese a que la OCH es una metaheurística reciente se han desarrollado muchos heurísticas basándose en ella. Aún así es un campo al que le resta bastante tiempo de vida ya que siguen presentándose día a día nuevas tendencias que pretenden mejorar la eficacia de los algoritmos de OCH o mejorar sus tiempos de ejecución.
Objetivo
Con esta practica queremos conocer las implementaciones de estos algoritmos en aplicaciones de software con metaheurísticas que ayuden a la humanidad en alguna porción pequeña de las miles o millones de implementaciones que se dan a diario con la finalidad de avanzar tecnológicamente. Nos proporciona herramientas para nuestra formación profesional, y la manera en que podemos plantearnos soluciones a problemas complejos que nos encontremos en el camino de nuestras labores cotidianas como desarrolladores, arquitectos y por que no, dueños de empresas enfocadas a dar soluciones mediante implementaciones de software
Justificación
La elaboración de la presente práctica es para conocer los diversos algoritmos existentes en la vida cotidiana; que ademas han sido implementados bajo la observación de actividades de elementos en la naturaleza, insectos, mamíferos, etc. Que tienden a tener conductas iterativas o repetitivas que les ayudan como colonia o como manada a superar las dificultades en el trayecto hacia su alimento o hacia un punto de migración; o simplemente para defenderse.
Bajo ese precepto la practica que implementamos ocupa realizar un algoritmo ACO por sus siglas en Ingles, y que pretende retroalimentar lo anteriormente mencionado sobre las colonias de hormigas
pH[w][0] = 18; // a
pH[w][1] = 49;
pN[w][0] = 30;
pN[w++][1] = 71;
pH[w][0] = 17; // b
pH[w][1] = 166;
pN[w][0] = 30;
pN[w++][1] = 185;
pH[w][0] = 17; // c
pH[w][1] = 281;
pN[w][0] = 30;
pN[w++][1] = 300;//y para cada uno de los puntos del camino
Basándonos en lo anterior las decisiones que toma la hormiga se programan de aquí hacia adelante
Finalmente dejaría un rastro que las demás hormigas deberían en su momento identificar, por lo que el camino quedaría marcado por las feromonas, determinando así el camino mas corto y con menor desgaste
Por ultimo este "ultimo" código es para la implementación de esta practica de manera gráfica con su GUI, en la cual se muestran las decisiones finales, donde obtiene el mejor camino a seguir, las variantes de los caminos, la cantidad de salidas disponibles, ademas de cada una de los pesos de cada uno de los puntos evaluados, el menor de los pesos definidos
Ángel Cobo Ortega, Ana María Serrano Bedia Un algoritmo híbrido basado en colonias de hormigas para la resolución de problemas de distribución en planta
orientados a procesos. Universidad de Cantabria. XIII Jornadas de ASEPUMA.
Cobo, A. y Serrano, A. (2001). Algoritmos genéticos para la resolución de
problemas de distribución en planta con restricciones espaciales. 5º Congreso CAIP.
Campos do Jordao (Brasil).
G. Brassard y P. Bratley. Fundamentals of Algorithmics. Prentice Hall, Englewood Cliffs, NJ, 1996.
McKendall, A. R. y Shang, J. (2004): Hybrid ant systems for the dynamic facility
layout problem, Computers and Operations Research, article in press.
Sergio Alonso, Oscar Cordón, Iñaki Fernández de Viana, Francisco Herrera. La Metaheurística de Optimización Basada en Colonias de Hormigas: Modelos y Nuevos Enfoques Departamento de Ciencias de la Computación e Inteligencia Artificial, E.T.S. Ingeniería Informática, C/ Periodista Daniel Saucedo Aranda s/n,18071 Granada(España)
Imágenes de http://en.wikipedia.org/wiki/Ant_colony_optimization_algorithms
Imagenes personales incluidas en el reporte generadas por el programa
