Hector

Lab1Demo.java

@@ -1,7 +1,8 @@
+// SCRIPT DE JAVA UTILIZADO PARA LANZAR EJECUCIONES SIMPLES
+
 import java.util.Scanner;
 
 import java.util.Iterator;
-import java.util.List;
 import java.util.Properties;
 
 import aima.search.framework.Problem;
@@ -12,100 +13,98 @@
 
 public class Lab1Demo {
     public static void main(String[] args){
+
+        // Se obtienen los parametros de la solucion
         Scanner scan = new Scanner(System.in);
         System.out.println("Cuantos participantes hay? (N)");
         int N = scan.nextInt();
         System.out.println("Cuantos son conductores? (M)");
         int M = scan.nextInt();
         System.out.println("Introduce una seed");
         int seed = scan.nextInt();
+        System.out.println("¿Qué algoritmo quieres usar? \n(1) Hill Climbing \n(2) Simulated Annealing");
+        int alg = scan.nextInt();
+        System.out.println("¿Qué heurística quieres usar? \n(1) Min distancia \n(2) Min distancia y conductores");
+        int h = scan.nextInt();
 
-
-
+        // Creacion y print del estado inicial, en caso de que sea posible crearlo
         System.out.println("\nSolución inicial  -->");
         Estado estado = new Estado(N, M, seed);
-        estado.solucionInicial5();
+        if (!estado.solucionInicial2()){ // Cambiar aquí la solución inicial
+            System.out.println("No se ha podido generar una solución inicial");
+            return;
+        } 
         mostrarMetricas(estado);
 
         long startTime = System.currentTimeMillis();
-        Lab1HillClimbingSearch(estado);
+        if (alg==1) Lab1HillClimbingSearch(estado, h); // Se realiza la busqueda local usando Hill Climbing
+        else Lab1SimulatedAnnealingSearch(estado, h); // Se realiza la busqueda local usando Simulated Annealing
         long endTime = System.currentTimeMillis();
         long elapsedTime = endTime - startTime;
         System.out.println("Tiempo de ejecución: " + elapsedTime + " milisegundos");
-
-        startTime = System.currentTimeMillis();
-        Lab1SimulatedAnnealingSearch(estado);
-        endTime = System.currentTimeMillis();
-        elapsedTime = endTime - startTime;
-        System.out.println("Tiempo de ejecución: " + elapsedTime + " milisegundos");
-
-        startTime = System.currentTimeMillis();
-        Lab1SimulatedAnnealingIterationSearch(estado);
-        endTime = System.currentTimeMillis();
-        elapsedTime = endTime - startTime;
-        System.out.println("Tiempo de ejecución: " + elapsedTime + " milisegundos");
     }
-
+
+
+        // Muestra por pantalla la lista de eventos, la distancia recorrida y el número de usuarios que hacen de conductor del (estado)
         private static void mostrarMetricas(Estado estado){
             int ncond = estado.numeroConductores();
-            int dist = estado.kilometrajeSolucion();
+            int dist = estado.kilometrajeEstado();
             System.out.println("Eventos: " + estado.getEventos());
             System.out.println("Distancia recorrida: " + dist);
             System.out.println("Conductores usados: " + ncond);
         }
 
-        private static void Lab1HillClimbingSearch(Estado estado) {
+
+        // Búsqueda utilizando el algoritmo de Hill-Climbing
+        private static void Lab1HillClimbingSearch(Estado estado, int h) {
             System.out.println("\nLab1 HillClimbing  -->");
             try {
-                Problem problem =  new Problem(estado,new Lab1SuccessorFunction(), new Lab1GoalTest(),new Lab1HeuristicFunction2());
+                Problem problem;
+                if (h==1) problem = new Problem(estado,new Lab1SuccessorFunction(), new Lab1GoalTest(),new Lab1HeuristicFunction1());
+                else problem = new Problem(estado,new Lab1SuccessorFunction(), new Lab1GoalTest(),new Lab1HeuristicFunction2());
                 Search search =  new HillClimbingSearch();
                 SearchAgent agent = new SearchAgent(problem,search);
 
-                //printActions(agent.getActions());
-                printInstrumentation(agent.getInstrumentation());
-
                 Estado estadoSolucion = (Estado) search.getGoalState();
                 mostrarMetricas(estadoSolucion);
-
+                printInstrumentation(agent.getInstrumentation());
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
 
-        private static void Lab1SimulatedAnnealingSearch(Estado estado) {
+
+        // Búsqueda utilizando el algoritmo de Simulated Annealing
+        private static void Lab1SimulatedAnnealingSearch(Estado estado, int h) {
             System.out.println("\nLab1 Simulated Annealing  -->");
             try {
-                Problem problem =  new Problem(estado,new Lab1SASuccessorFunction(), new Lab1GoalTest(),new Lab1HeuristicFunction2());
-                SimulatedAnnealingSearch search =  new SimulatedAnnealingSearch(100000,100,10,0.001);
-                //search.traceOn();
-                SearchAgent agent = new SearchAgent(problem,search);
-                //printActions(agent.getActions());
-                printInstrumentation(agent.getInstrumentation());
-
-                Estado estadoSolucion = (Estado) search.getGoalState();
-                mostrarMetricas(estadoSolucion);
-            } catch (Exception e) {
-                e.printStackTrace();
-            }
-        }
+                // Definición de los parámetros del algoritmo
+                int it = 10000000;
+                int itpc = 100;
+                int k = 25;
+                double lambda = 0.0001;
 
-        private static void Lab1SimulatedAnnealingIterationSearch(Estado estado) {
-            System.out.println("\nLab1 Simulated Annealing  Iterations-->");
-            try {
-                Problem problem =  new Problem(estado,new Lab1SAIterationsSuccessorFunction(), new Lab1GoalTest(),new Lab1HeuristicFunction2());
-                SimulatedAnnealingSearch search =  new SimulatedAnnealingSearch(100000,100,10,0.001);
+                Problem problem;
+                if (h==1) problem = new Problem(estado,new Lab1SASuccessorFunction(), new Lab1GoalTest(),new Lab1HeuristicFunction1());
+                else problem = new Problem(estado,new Lab1SASuccessorFunction(), new Lab1GoalTest(),new Lab1HeuristicFunction2());
+                SimulatedAnnealingSearch search =  new SimulatedAnnealingSearch(it, itpc, k, lambda); 
                 //search.traceOn();
                 SearchAgent agent = new SearchAgent(problem,search);
-                //printActions(agent.getActions());
-                printInstrumentation(agent.getInstrumentation());
 
                 Estado estadoSolucion = (Estado) search.getGoalState();
                 mostrarMetricas(estadoSolucion);
+                System.out.println("It: " + it + ". It por cambio de temperatura: " + itpc + ". k: " + k + ". lambda: " + lambda);
+                printInstrumentation(agent.getInstrumentation());
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
 
+
+        //*********************************************************************************************
+        //******************************* FUNCIONES AUXILIARES ****************************************
+        //*********************************************************************************************
+
         private static void printInstrumentation(Properties properties) {
             Iterator keys = properties.keySet().iterator();
             while (keys.hasNext()) {
@@ -115,12 +114,5 @@ private static void printInstrumentation(Properties properties) {
             }
 
         }
-
-        private static void printActions(List actions) {
-            for (int i = 0; i < actions.size(); i++) {
-                String action = (String) actions.get(i);
-                System.out.println(action);
-            }
-        }
 
 }

Lab1Experimentos.java

@@ -0,0 +1,116 @@
+// SCRIPT DE JAVA UTILIZADO PARA EL DISEÑO DE EXPERIMENTOS
+
+import java.util.Iterator;
+import java.util.Properties;
+
+import aima.search.framework.Problem;
+import aima.search.framework.Search;
+import aima.search.framework.SearchAgent;
+import aima.search.informed.HillClimbingSearch;
+import aima.search.informed.SimulatedAnnealingSearch;
+
+public class Lab1Experimentos {
+    public static void main(String[] args){
+
+        int N, M, seed, alg, h;
+
+        if (args.length != 5) {
+            System.out.println("Debes ingresar 5 valores separados por espacios");
+            return;
+        }
+
+        N = Integer.parseInt(args[0]);
+        M = Integer.parseInt(args[1]);
+        seed = Integer.parseInt(args[2]);
+        alg = Integer.parseInt(args[3]);
+        h = Integer.parseInt(args[4]);
+
+        // Creacion y print del estado inicial, en caso de que sea posible crearlo
+        System.out.println("\nSolución inicial  -->");
+        Estado estado = new Estado(N, M, seed);
+        if (!estado.solucionInicial2()){ // Cambiar aquí la solución inicial
+            System.out.println("No se ha podido generar una solución inicial");
+            return;
+        } 
+        mostrarMetricas(estado);
+
+        long startTime = System.currentTimeMillis();
+        if (alg==1) Lab1HillClimbingSearch(estado, h); // Se realiza la busqueda local usando Hill Climbing
+        else Lab1SimulatedAnnealingSearch(estado, h); // Se realiza la busqueda local usando Simulated Annealing
+        long endTime = System.currentTimeMillis();
+        long elapsedTime = endTime - startTime;
+        System.out.println("Tiempo de ejecución: " + elapsedTime + " milisegundos");
+    }
+
+
+        // Muestra por pantalla la lista de eventos, la distancia recorrida y el número de usuarios que hacen de conductor del (estado)
+        private static void mostrarMetricas(Estado estado){
+            int ncond = estado.numeroConductores();
+            int dist = estado.kilometrajeEstado();
+            System.out.println("Eventos: " + estado.getEventos());
+            System.out.println("Distancia recorrida: " + dist);
+            System.out.println("Conductores usados: " + ncond);
+        }
+
+
+        // Búsqueda utilizando el algoritmo de Hill-Climbing
+        private static void Lab1HillClimbingSearch(Estado estado, int h) {
+            System.out.println("\nLab1 HillClimbing  -->");
+            try {
+                Problem problem;
+                if (h==1) problem = new Problem(estado,new Lab1SuccessorFunction(), new Lab1GoalTest(),new Lab1HeuristicFunction1());
+                else problem = new Problem(estado,new Lab1SuccessorFunction(), new Lab1GoalTest(),new Lab1HeuristicFunction2());
+                Search search =  new HillClimbingSearch();
+                SearchAgent agent = new SearchAgent(problem,search);
+
+                Estado estadoSolucion = (Estado) search.getGoalState();
+                mostrarMetricas(estadoSolucion);
+                printInstrumentation(agent.getInstrumentation());
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
+
+        // Búsqueda utilizando el algoritmo de Simulated Annealing
+        private static void Lab1SimulatedAnnealingSearch(Estado estado, int h) {
+            System.out.println("\nLab1 Simulated Annealing  -->");
+            try {
+                // Definición de los parámetros del algoritmo
+                int it = 1000000;
+                int itpc = 100;
+                int k = 25;
+                double lambda = 0.0001;
+
+                Problem problem;
+                if (h==1) problem = new Problem(estado,new Lab1SASuccessorFunction(), new Lab1GoalTest(),new Lab1HeuristicFunction1());
+                else problem = new Problem(estado,new Lab1SASuccessorFunction(), new Lab1GoalTest(),new Lab1HeuristicFunction2());
+                SimulatedAnnealingSearch search =  new SimulatedAnnealingSearch(it, itpc, k, lambda); 
+                //search.traceOn();
+                SearchAgent agent = new SearchAgent(problem,search);
+
+                Estado estadoSolucion = (Estado) search.getGoalState();
+                mostrarMetricas(estadoSolucion);
+                System.out.println("It: " + it + ". It por cambio de temperatura: " + itpc + ". k: " + k + ". lambda: " + lambda);
+                printInstrumentation(agent.getInstrumentation());
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
+
+        //*********************************************************************************************
+        //******************************* FUNCIONES AUXILIARES ****************************************
+        //*********************************************************************************************
+
+        private static void printInstrumentation(Properties properties) {
+            Iterator keys = properties.keySet().iterator();
+            while (keys.hasNext()) {
+                String key = (String) keys.next();
+                String property = properties.getProperty(key);
+                System.out.println(key + " : " + property);
+            }
+
+        }
+
+}

Lab1HeuristicFunction1.java

@@ -1,3 +1,5 @@
+// DEFINICIÓN DE LA FUNCIÓN HEURISTICA 1
+
 import aima.search.framework.HeuristicFunction;
 
 public class Lab1HeuristicFunction1 implements HeuristicFunction  {
@@ -11,8 +13,8 @@ public boolean equals(Object obj) {
 
   // Heurística 1: Se considera únicamente la suma de distancia recorrida por todos los conductores
   public double getHeuristicValue(Object s) {
-    Estado estado = (Estado)s;
-    return estado.kilometrajeSolucion();
+      Estado estado = (Estado)s;
+      return estado.kilometrajeEstado();
   }  
 }
 

Lab1HeuristicFunction2.java

@@ -1,11 +1,5 @@
 // DEFINICIÓN DE LA FUNCIÓN HEURISTICA 2
 
-// Penalizar manzanas sin pasajeros completos (antes de acabar la trayectoria?)
-
-// Solución Inicial --> Poner a cada conductor pasajeros dentro del rectangulo de su path.
-
-import java.util.ArrayList;
-
 import aima.search.framework.HeuristicFunction;
 
 public class Lab1HeuristicFunction2 implements HeuristicFunction  {
@@ -17,34 +11,10 @@ public boolean equals(Object obj) {
         return retValue;
     }
 
-
-    public double getHeuristicValue(Object s) {
-        Estado estado = (Estado)s;
-        ArrayList<ArrayList<Integer>> eventos = estado.getEventos();
-        double ncond = 0;
-        for (int i=0; i<estado.getM(); i++){
-            if (eventos.get(i).size()>0) {
-                ncond+=1;
-            }
-        }
-        //System.out.println(sum/(300*estado.getN()) + (ncond/estado.getM()));
-        return 0.75*estado.kilometrajeSolucion()/estado.get_distInicial() + 0.25*ncond/estado.getM();
-    }
-
-    /*
     // Heurística 2: Se considera la suma de la distancia recorrida por todos los conductores y el número de conductores de la solución
-    // REDEFINIR QUÉ IMPORTANCIA LE DAMOS A CADA COSA (CONDUCTORES Y KM)!!
     public double getHeuristicValue(Object s) {
         Estado estado = (Estado)s;
-        ArrayList<ArrayList<Integer>> eventos = estado.getEventos();
-        int sum = 0;
-        for (int i=0; i<estado.M; i++){
-            if (eventos.get(i).size()>0) {
-                sum += estado.kilometrajeConductor_manzanasLibres(eventos.get(i));
-            }
-        }
-        return sum;
-    }*/
-
+        return estado.kilometrajeEstado() + 70*estado.numeroConductores();
+    }
 
 }