Ejemplos redes neuronales

Ejemplos del framework Neuroph Java: http://neuroph.sourceforge.net/sample_projects.html
Reconocimiento de imágenes
Manual de Neuroph

Ejemplo de Algoritmo Genético

Los pasos de todo algoritmo genético deben de ser

• Generar población
• Seleccionar a los individuos mas aptos (Torneo, selección por ruleta, etc)
• Cruzarlos (recombinacion)
• Mutación

Podemos ubicar las ciudades en un plano cartesiano y verlas como si fueran puntos, desde esa perspectiva es posible sacar la distancia total del recorrido aplicando distancia euclidiana entre los puntos.

Después de eso podemos realizar una selección, entre los métodos mas comunes están el de selección por ruleta o el de selección por torneo, en este ultimo tan solo tenemos que ordenar la lista de caminos de menor a mayor y en mi caso elegir n * 3 individuos que representaran a los padres de la siguiente generación, ahora, en este punto es importante saber cuales tenemos que elegir ya que en probabilidad es poco posible que si cruzamos los 2 individuos mejor adaptados de la generación salga uno aun mas adaptado, por el contrario podría “des evolucionar” el hijo, es por eso que yo recomiendo, si vemos la población como si estuviera ordenada en una pila, tomar de los de arriba (los mejores adaptados) y algunos de en medio.

En este punto ya tenemos a los que serán los padres, ahora debemos de cruzarlos, existen varias técnicas de cruza como recombinación en 1 punto, recombinación en 2 puntos, corte y empalme, Recombinación uniforme y uniforme media y Recombinación de cromosomas ordenados, mas información aqui.

En este caso se hace una recombinación en 2 puntos y después se un algoritmo de mi creación para corregir el camino en caso de que hubiera ciudades repetidas en el.

Código de ejemplo:

• mainInterface.java
• GeneticsAlgorithm.java
• City.java
• Path.java

8 Reinas con algoritmos genéticos: https://www.youtube.com/watch?v=L3mQ7fYdK_k

Comportamientos-subsumption-Behaviour

http://sintelweb.blogspot.mx/2011/11/creacion-y-aplicacion-de-la.html
http://blog.electricbricks.com/2010/06/lejos-task-schedulin-arbitrator/

Lejos SUMO

http://users.humboldt.edu/aschmidt/sumoBot.php

DifferentialPilot

public DifferentialPilot(double wheelDiameter,
                         double trackWidth,
                         RegulatedMotor leftMotor,
                         RegulatedMotor rightMotor,
                         boolean reverse)

Parámetros:

wheelDiameter - Diámetro en mm de la llanta.

trackWidth - Distancia en mm entre el centro de la llanta derecha y el centro de la llanta izquierda.

leftMotor - Motor izquierdo.

rightMotor - Motor derecho.

reverse -Si es verdadero, el robot NXT se mueve hacia adelante cuando los motores están girando hacia atrás.

Tarea

Mapa conceptual sobre razonamiento que incluya los puntos:

• Métodos de búsqueda
• Espacio de estados
• Incertidumbre
• Estrategias de control hacia delante.

Exposiciones para el viernes 31.
Equipo 1 (Cesar y Javier) Razonamiento: http://disi.unal.edu.co/~lctorress/iartificial/IAc007.pdf y buscar el tema de lógica difusa.

Equipo 2 (Victor, Alan y Oscar). Agentes: http://www.uv.mx/aguerra/documents/2013-ia2.pdf

Complementar con un ejemplo por cada integrante acerca del subtema expuesto.

Actividad

Hacer un mapa conceptual individualmente del siguiente artículo:
http://www.iit.upcomillas.es/pfc/resumenes/4df6204c562f5.pdf

Grabar videos del laberinto y seguidor de línea.

Seguidor de línea

import lejos.nxt.Button;
import lejos.nxt.LCD;
import lejos.nxt.LightSensor;
import lejos.nxt.Motor;
import lejos.nxt.SensorPort;

public class SigueLineasP {

public static void main(String[] args) throws Exception
{
LightSensor sluz = new LightSensor(SensorPort.S1);
int error, max, min, med;

min = sluz.readNormalizedValue();
LCD.drawString("Valor minimo:", 2, 3);
LCD.drawInt(min, 4, 6, 5);
Thread.sleep(2000);

Motor.A.rotate(-90,true);
Motor.B.rotate(90);
max = sluz.readNormalizedValue();
LCD.clear();
LCD.drawString("Valor maximo:", 2, 3);
LCD.drawInt(max, 4, 6, 5);
Thread.sleep(2000);

Motor.A.rotate(45,true);
Motor.B.rotate(-45);
med = (max + min)/ 2;
LCD.clear();
LCD.drawString("Valor medio:", 2, 3);
LCD.drawInt(med, 4, 6, 5);
Thread.sleep(2000);

Motor.A.forward();
Motor.B.forward();
LCD.clear();
LCD.drawString("Pulse ESCAPE", 2, 3);
LCD.drawString("para parar", 3, 5);
while (true) {
error = med - sluz.readNormalizedValue();
Motor.A.setSpeed(300 - error);
Motor.B.setSpeed(300 + error);
if (Button.ESCAPE.isPressed()){
break;
}
}
// TODO Auto-generated method stub
}

}

Laberinto

import lejos.nxt.*;
import java.io.*;

public class Labyrinth1 {
 
 //CONSTANTS
 private static int forwardStep = 720;
 private static int turnStep = 410;
 private static int fdist = 15;
 private static int slack = 20;
 private static int turnSpeed = 200;
 private static int straightSpeed = 400;
 
 //VARIABLES
 private static Motor rightMotor = Motor.B;
 private static Motor leftMotor = Motor.C;
 private static TouchSensor leftSensor = new TouchSensor(SensorPort.S2);
 private static TouchSensor rightSensor = new TouchSensor(SensorPort.S1);
 private static PrintStream console = new PrintStream(new LCDOutputStream());
 private static UltrasonicSensor sens = new UltrasonicSensor(SensorPort.S4);
 
 public static void main (String[] aArg) {

  //right hand rule
  while(true){
   try{
    while(moveOneSquare() == false)
     //do nothing
     ;
    
    rightMotor.setSpeed(turnSpeed);
    leftMotor.setSpeed(turnSpeed);
    
    console.println("Looking Right");
    //prepara a girar
    rightSlack();
    turnRight();
    //pone en neutral
    leftSlack();
    if (sens.getDistance()<fdist){
     console.println("Looking Front");
     //prepara a girar
     leftSlack();
     turnLeft();
     if(sens.getDistance()<fdist){
      console.println("Looking Left");
      turnLeft();
      if(sens.getDistance()<fdist){
       console.println("Going Back");
       turnLeft();
      }
     }
    }
    //pone en neutral
    rightSlack();
    
    if (leftSensor.isPressed() || rightSensor.isPressed())
     panic();
    
    //Stop wobbling
    Thread.sleep(200);
   }
   catch(Exception ex) {
    console.println("Something happened.\nI dont care.");
   }
  }
 }
 
 private static boolean moveOneSquare() throws Exception{
  boolean left, right;
  rightMotor.setSpeed(straightSpeed);
  leftMotor.setSpeed(straightSpeed);
  rightMotor.resetTachoCount();
  leftMotor.resetTachoCount();
  
  leftMotor.rotate(forwardStep,true);
  rightMotor.rotate(forwardStep, true);
  
  while(leftMotor.isRotating() && rightMotor.isRotating()){
   left = leftSensor.isPressed();
   right = rightSensor.isPressed();
   if ( left || right ){
    leftMotor.stop();
    rightMotor.stop();
    leftMotor.rotate(-leftMotor.getTachoCount(),true);
    rightMotor.rotate(-rightMotor.getTachoCount(), false);
    if (left && right){
     panic();
    }
    //left
    else if(left){
     rightMotor.rotate(-turnStep/5);
    }
    //right
    else {
     leftMotor.rotate(-turnStep/5);
    }  
    //try again!
    return false;
   }
  }
  //success!!
  return true;
 }
 
 //tensar la cuerda (== los engranages)
 //para que un giro a la derecha empieza de inmediato
 private static void rightSlack() throws Exception{
  rightMotor.rotate(-slack,true);
  leftMotor.rotate(slack,false);
  Thread.sleep(200);
 }
 //tensar la cuerda (== los engranages)
 //para que un giro a la izquierda empieza de inmediato
 private static void leftSlack() throws Exception {
  leftMotor.rotate(-slack,true);
  rightMotor.rotate(slack,false);
  Thread.sleep(200);
 }
 private static void turnRight() throws Exception {
  rightMotor.rotate(-(turnStep-30),true);
  leftMotor.rotate(turnStep-30,false);
  Thread.sleep(200);
 }
 private static void turnLeft() throws Exception {
  leftMotor.rotate(-turnStep,true);
  rightMotor.rotate(turnStep,false);
  Thread.sleep(200);
 }
 private static void panic() throws Exception {
  console.println("!!! HELP !!!");
  console.println("Put me straight and center");
  console.println("and press Enter.");
  Sound.beepSequenceUp();
  Button.ENTER.waitForPressAndRelease();
 }
}

Otra fuente: http://agentesotono2010.blogspot.mx/2010/11/mindstorms-nxt-lejos-salir-de-un.html

Api TachoPilot de Lejos

http://www.roboticaenlaescuela.es/blog/wp-content/uploads/2011/02/ejemplosBaseCloneWars.pdf

http://www.lejos.org/p_technologies/nxt/nxj/api/lejos/navigation/Pilot.html

El paquete lejos.navigation contiene  interfaces y clases para la navegación
abstracta.
La clase Pilot permite controlar un robot de tracción diferencial sin tener que lidiar con el control individual del motor.

Ejemplos:
pilot.backward();
pilot.travel(20);
float dist =
pilot.getTravelDistance();
pilot.resetTachoCount();

Sensores y motores

http://socrates.bmcc.cuny.edu/mkok/Sensors.html#Ultrasound

http://blog.electricbricks.com/2010/03/tutorial-java-lejos-lego-mindstorms-nxt-8/

http://inghobbit.blogspot.mx/2011/05/ejemplo-programa-con-lejos-para-el-lego.html

Comandos Lejos

https://wiki.dcc.uchile.cl/TallerMindstorms/doku.php?id=notas_de_lejos

http://docencia.etsit.urjc.es/moodle/file.php/11/Practicas/11_12/practicas.pdf

Proyecto Lego

https://www.youtube.com/watch?v=14PswDr0otE

Que el lego sea capaz de lo siguiente:

1. Seguir una línea
2. Evadir obstáculos
3. Adaptarse a cambios en el ambiente
4. Navegar y salir de un laberinto
5. Seguir (empujar) ciertos objetos
6. y a Futuro que pueda diferenciar y clasificar objetos.

Instalación LEJO

Prueba hola mundo, instalación y configuración
http://robotlego.wordpress.com/2008/06/15/tutorial-como-instalar-y-correr-java-con-un-robot-lego-mindstorms-nxt-usando-eclipse-metodo-alternativo/

Componentes:
http://www.julio.sandria.org/archivos/docencia/2009-11-citir-nxt-java/sandria2009-pr_nxt_j-05e.pdf

Ejemplos:
http://www.julio.sandria.org/archivos/articulos/programacion/java/lejos-nxj/sandria2010-instalacion_lejos-nxj_windows-xp-vista-7.pdf
http://www.julio.sandria.org/archivos/articulos/robotica/lego-nxt/seguidor-linea/Sandria2013-Robot_Seguidor_Linea_NXT.pdf
https://www.youtube.com/watch?feature=player_embedded&v=cgdhTouEPjk

Uso y configuración de robots lego

http://profesores.elo.utfsm.cl/~agv/elo329/1s05/projects/barrallon.contreras.sterneberg/
A detalle:  http://robotlego.wordpress.com/2008/06/15/tutorial-como-instalar-y-correr-java-con-un-robot-lego-mindstorms-nxt-usando-eclipse-metodo-alternativo/

Ejemplos:
http://robotlego1004.blogspot.mx/

Lego Mindstorm

http://www.julio.sandria.org/archivos/docencia/2009-11-citir-nxt-java/sandria2009-pr_nxt_j-05e.pdf

Redes y Marcos

A partir de página 10:
https://www.cs.us.es/cursos/ia2-2002/temas/tema-4.pdf

http://es.slideshare.net/miramire/unidad-no-4-representacin-del-conocimiento?next_slideshow=1

Sistema experto de nutrición

Art Sistema Nutricion by Ana Luisa Ballinas Hernandez

Resumen comandos Prolog: http://www.gedlc.ulpgc.es/docencia/lp/documentacion/GB_Prolog.pdf

Redes semánticas

Prolog es un lenguaje muy adaptado para el desarrollo de aplicaciones en Inteligencia Artificial, en las que un problema básico es representar el conocimiento de un dominio concreto de forma que pueda ser interpretado correctamente en la computadora. Uno de los métodos de representación, basado en modelos de psicología cognitiva, son las redes semánticas. Las redes semánticas son grafos orientados que proporcionan una representación declarativa de objetos, propiedades y relaciones. Los nodos se utilizan para representar objetos o propiedades. Los arcos representan relaciones entre nodos del tipo es_un, es_parte_de, etc. El mecanismo de inferencia básico en las redes semánticas es la herencia de propiedades.

Explicación
http://web.ing.puc.cl/~jabaier/iic2612/leng_natural1.pdf

Ejercicios
http://www.nebrija.es/~cmalagon/ia/ejercicios/Ejercicios_redes_semanticas.pdf

Reconocimiento de voz

Para empezar lo que necesitamos es decirle a nuestra aplicación cuales son los permisos que necesitará desde el AndroidManifest.xml. Para ello debemos añadir la siguiente línea dentro del archivo antes mencionado:

<uses-permission android:name="android.permission.INTERNET" />

Una vez hecho este paso previo vamos a implementar el reconocimiento de voz. Para ello abrimos nuestra activity principal e incluimos el siguiente código:

private static final int VOICE_RECOGNITION_REQUEST_CODE = 1234;

Private Button btnVoice; 


private void inicializarReconocimiento(){

btnVoice = (Button) findViewById(R.id.btnVoice);


PackageManager pm = getPackageManager();         

List<ResolveInfo> activities = pm.queryIntentActivities(new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH), 0);           

if (activities.size() != 0) { 

btnVoice.setOnClickListener(new OnClickListener() {                  

public void onClick(View v) {                

 startVoiceRecognitionActivity();             

}         });           } 


}

Lo que estamos haciendo aquí es inicializar un botón para poder lanzar el reconocimiento y comprobando que está disponible este servicio en el dispositivo. Vamos a ver que es lo que hace el método startVoiceRecognitionActivity que lanza nuestro botón.

private void startVoiceRecognitionActivity() {        Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);         intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,                 RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);         intent.putExtra(RecognizerIntent.EXTRA_PROMPT, "");         startActivityForResult(intent, VOICE_RECOGNITION_REQUEST_CODE);     }

El método es muy sencillo . Lo que hace es llamar al intent correspondiente del reconocimiento, abriendo una nueva actividad que devolverá un resultado, en este caso devolverá los posibles resultados. Tambien le pasamos la variable VOICE_RECOGNITION_REQUEST_CODE que luego utilizaremos en el método onActivityResult. Esto veremos ahora para que sirve.

@Override


protected void onActivityResult(int requestCode, int resultCode, Intent data) {         
 if (requestCode == VOICE_RECOGNITION_REQUEST_CODE && resultCode == RESULT_OK) {          
  ArrayList<String> matches = data.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);                        
  final CharSequence[] items = new CharSequence[matches.size()];    
  for(int i = 0; i < matches.size(); i++){     
    items[i] = matches.get(i);    
  }                    
  AlertDialog.Builder builder = new AlertDialog.Builder(this);
  builder.setTitle(selectResult);        
  builder.setItems(items, new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface dialog, int item) {
     txtSearch.setText(items[item].toString());              
     }
  });
         
  AlertDialog alert = builder.create();          
  alert.show();                      
 }         
 super.onActivityResult(requestCode, resultCode, data);     
}

Lo que estamos haciendo ahora es sobreescribir el método OnActivityResult de nuestro activity. Este método es lanzado cuando una activity secundaria que hemos lanzado desde nuestra activity principal devuelve un resultado . Por ejemplo, después de reconocer lo que hemos dicho, devolverá un resultado con las posibles frases que ha reconocido el servicio.

Lo primero que hacemos es verificar el resultCode que es una especie de identificador para saber de que activity proviene el resultado. Es para esto para lo que utilizamos la variable anterior.

También verificamos que el resultado de nuestra activity secundaria ha sido satisfactorio con resultCode.
Una vez hechas las comprobaciones parseamos los resultados que en este caso va a ser una lista de frases y los cuales podemos mostrar con un AlertDialog por ejemplo. En este seleccionamos un resultado y lo seteamos en un TextView, txtSearch. A partir de aquí el como se utilicen los resultados ya es cosa de cada uno.

Ejemplo

Reconocimiento para hacer llamadas http://www.tutorialeshtml5.com/2013/03/tutorial-simple-reconocimiento-de-voz.html

Aplicaciones de los Sistemas Expertos

Método de encadenamiento hacia atrás o backtracking

Un motor de inferencia de encadenamiento hacia atrás comienza con una hipótesis (objeto) y pide información para confirmarlo o negarlo. A este método se le llama conducido por objetos porque el SE empieza con un objeto e intenta verificarlo. El encadenamiento hacia atrás poda un árbol.

Ejemplos: http://sergioc2005.tripod.com/intart/Pract7SistExpertProlog06.pdf

TAREA:
Hacer mapa conceptual en CmapTools del siguiente artículo: http://teyet-revista.info.unlp.edu.ar/nuevo/files/No11/TEYET11-art10.pdf

Sistemas Expertos en Prolog

Repaso Prolog: http://elvex.ugr.es/decsai/intelligent/workbook/ai/PROLOG.pdf
Gráficos en Prolog: http://www.dccia.ua.es/logica/prolog/docs/ProgGUI.pdf

XPCE/Prolog

Se hace uso de la librería XPCE, la cual ha sido desarrollada para el desarrollo en GUI Prolog.

CARGANDO LA LIBRERÍA PCE

Para poder usar predicados para trabajar con gráficos bajo Prolog deberemos cargar la librería PCE.

:- use_module(library(pce)).

Esta línea lo que hace es decirle a Prolog que cargue la librería una vez ha terminado de compilar, antes de que desde el prompt de Prolog se nos deje hacer ninguna consulta. Una vez cargada esta librería, ya disponemos de una serie de predicados para poder crear ventanas, botones, y una gran variedad de objetos.

CREANDO OBJETOS PARA LUEGO INTERACTUAR
Con la librería PCE se trabaja con un esquema orientado a objetos, en  donde podremos crear clases y trabajar con diferentes objetos, pudiendo llamar a métodos de dichos objetos (pasándoles los correspondientes parámetros) o llamar a métodos que nos devuelvan algún valor, y obviamente si creamos objetos, también podremos destruirlos.

Existen 4 predicados con los que se puede trabajar con XPCE/Prolog. Estos predicados sirven para crear objetos, enviar mensajes a objetos, recibir mensajes de objetos y liberar la memoria de los objetos.

·         new(?Reference, +NewTerm): Este predicado recoge dos parámetros, el primero recogería la referencia que se le asigna al nuevo objeto, ya que new se usa para crear objetos. El segundo parámetro le indicaría el objeto que se quiere crear.

·         send(?Receiver, +Selector(...Args...)): El primer parámetro del predicado es una referencia al objeto al que deseemos enviarle un mensaje. El segundo parámetro indicará el método al que queremos invocar, lo cual indicaremos junto a los argumentos que queremos enviarle al método.

·         get(?Receiver, +Selector(+Argument...), -Result): Los dos primeros parámetros tienen el mismo significado que para send, sin embargo el último parámetro sirve para recoger el valor que nos devuelva el método que hallamos invocado.

·         free(?Reference): libera la memoria asociada al objeto que se le indica en el primer parámetro.

Las referencias se usan para saber a que objeto nos referimos, así pues cada objeto que creemos deberá tener su propia referencia, ya que después toda memoria que  reservemos con new, será conveniente liberarla con free. Las variables de referencia deben crearse con el símbolo @ y el nombre de la VAR. Posteriormente se liberara con free.

MANOS A LA OBRA: Crear un dialogo que contenga un botón y que al pulsar sobre el mismo cierre esa ventana.

:- use_module(library(pce)).

ejemplo:-

/*

* Crea el objeto dialogo en la variable D

*/

new(D,dialog('Nombre del Dialogo')),

/*

* Crea el objeto boton almacenandolo en la variable @boton de tal forma

* que al pulsar sobre el boton libere la memoria y cierre la ventana)

*/

new(@boton, button('Cerrar Dialogo',

and(message(D, destroy),message(D, free),message(@boton, free)))),

/*

* Inserta el botón en el diálogo

*/

send(D, append(@boton)),

/*

* Le envia el mensaje open al dialogo para que cree y muestre la ventana.

*/

send(D, open).

Diagnosticar enfermedades: https://www.youtube.com/watch?v=xzmiO72G9mE