Metaheurstica

MetaheursticaPrctica 1a: Metaheursticas basadas en trayectorias

Algoritmos empleados: Greedy, Bsqueda local y Bsqeuda Tab.

Juan Antonio Prez Cruz 77362120X japc0010@red.ujaen.esJuana Mara Rodrguez Garca 77363220Yjmrg0021@red.ujaen.esGrupo 2: 12.30-14:3021/10/2014

ndiceDescripcin del problema.2Descripcin de la aplicacin de los algoritmos..3Lectura del fichero.3Coste de la funcin objetivo3Factorizacin.4Solucin inicial.4Estructura del mtodo de bsqueda.5Bsqueda local.5Bsqueda tab....6 Algoritmo de comparacin: bsqueda Greedy.....9Breve manual de usuario.10Experimentos y anlisis de resultados...11Referencias bibliogrficas14

Descripcin del problemaEl problema que debemos resolver se denomina asignacin cuadrtica (QAP). Es uno de los problemas de optimizacin combinatoria ms conocidos.Se dispone de n unidades y n localizaciones para situarlas. El problema pues, consiste en encontrar la asignacin ptima de cada unidad a una localizacin.La funcin objetivo mide en este caso la bondad de una asignacin y considera el producto de la distancia entre cada par de localizaciones y el flujo que circula entre cada par de unidades.De ah que se hable de funcin cuadrtica, puesto que considera el producto de dos trminos.La frmula del QAP quedara:

es una solucin al problema que consiste en una permutacin que representa la asignacin de la unidad i a la localizacin (i) es el flujo que circula entre la unidad i y la j. es la distancia existente entre la localizacin k y la l.

Descripcin de la aplicacin de los algoritmosLectura del fichero:PROCEDIMIENTO lecturaFichero( nombre: cadena, VAR flujo:array(tam,tam) de entero, VAR distancias: array(tam,tam) de entero, VAR tam:entero) leerfichero(fp, tam);//Especifica el tamao de la matrizCoger_memoria(distancias);Coger_memoria(flujo);

//Lectura de los datos de las distanciasPara i = 0 hasta tam-1 hacerPara j = 0 hasta tam-1 hacerleerfichero (fp, distancias [i][j]);//Lectura de los flujosPara i = 0 hasta tam-1 hacerPara j = 0 hasta tam-1 hacerleerfichero (fp, flujo [i][j]);}

Coste de la funcin objetivo:Se utiliza aqu un vector llamado s de tamao tam que contiene las localizaciones insertadas en las posiciones del vector que estas indican.FUNCION coste (s: array de enteros, flujo:array()(tam), localizaciones: array()(tam), tam:entero) coste:entero = 0 Para i = 0 Hasta tam Hacer Para j = 0 Hasta tam Hacer coste += flujo(i)(j) * localizaciones(s(i),(s(j)) Fin_Para Fin_ParaDevolver coste

Factorizacin:Haremos uso de esta funcin, puesto que la funcin del coste tiene mucho costo computacional. Al hacer cualquier cambio para representar nuestra solucin empleamos un valor actual r y otro s, cuando generamos nuevas secuencias vecinas en cada movimiento.FUNCION factorizacion (solActual:array de enteros, , flujo :array()(tam), localizaciones:array(tam)(tam), tam:entero, s:entero, r:entero) costeActual:entero = 0 Para k = 0 Hasta tam Hacer Si k es distinto de r Y k es distinto de s entonces costeActual += flujo(r)(k)*(localizaciones(solActual(s))(solActual(k)) localizaciones(solActual(r))(solActual(k))) + flujo(s)(k)*(localizaciones(solActual(r)(solActual(k)) l localizaciones (solActual(s))(solActual(k))) + flujo(k)(r)*(localizaciones(solActual[k))(solActual[s)) - localizaciones [solActual(k))[solActual[r))) + flujo(k)(r)*(localizaciones(solActual(k))[solActual[r)) - localizaciones [solActual[k))(solActual[s))) Fin_Si Fin_Para Devolver costeActual;

Solucin inicial:Haremos uso de una solucin inicial aleatoria a partir de una semilla:PROCEDIMIENTO solucionInicial (s:array de enteros, tam:entero, semilla:entero) { numAleatorio(semilla);

// primero vamos a inicializar todo el vector a -1 Para i = 0 Hasta tam Hacer s(i) = -1; Fin_Para

Para i = 0 Hasta tam Hacer x:entero = numAleatorio entre 0 y tam-1 Si i igual a 0 s(i) = x Si_no Para j =0 Hasta i Hacer Si s(j) es igual a x i-- Salimos del bucle Si_no s(i) = x Fin_Si_no Fin_Para Fin_Si_no

Estructura del mtodo de bsquedaBsqueda LocalEsta funcin sirve para permutar.FUNCION swap (solActual : array de enteros, r:entero, s:entero) aux:entero aux = solActual[r] solActual[r] = solActual[s] solActual[s] = aux

La solucin que obtenemos con la bsqueda local est basada en el pseudocdigo del seminario: Dont Look Bits: En la primera iteracin, todos los bits estn a 0, es decir, todas las unidades estn activadas en un bucle externo y todos sus movimientos pueden ser considerados para explorar el entorno:a) Si tras probar todos los movimientos asociados a esa unidad, ninguno provoca una mejora, se pone su bit a 1 para desactivarla en el futurob) b) Si una unidad est implicada en un movimiento que genera una solucin vecina con mejor coste, se pone su bit a 0 para reactivarlaFUNCION solucionBL(flu:array de enteros, loc:array de enteros, tam:int, &solucionActual:array de enteros) dlb(tam):array de enteros mejora:bool costeActual : entero = coste(solucionActual, flu, loc, tam) Para int i = 0 Hasta tam Hacer Si (dlb(i) es igual a 0) mejoria = false Para int j = i + 1 Hasta tam Hacer c : entero = factorizacion(solucionActual, flu, loc, tam, costeActual, i, j) Si (c < costeActual) swap(solucionActual, i, j) costeActual = c mejoria = true dlb(i) = false // 0 dlb(j) = false // 0 i = 0 // para empezar desde el principio la bsqueda Fin_Si Fin_Para Si (mejora es igual a false) dlb(i) = true //1 Fin_Si Fin_Para

Bsqueda TabConsideramos en este algoritmo una lista de movimientos tab que permitirn o no seleccionar a unos vecinos generados en cada iteracin. Se coge entonces al mejor de estos, dejando a un lado la funcin objetivo. Para mejorar las posibles soluciones se hace una re-inicializacin de la bsqueda, despus de 10 iteraciones sin mejora. Esto lo haremos de tres formas distintas: desde una nueva solucin aleatoria (mejorando diversidad), desde una mejor solucin encontrada hasta el momento (mejorando la intensificacin), o desde la solucin menos frecuente que se ha dado (controlando la diversidad).

Parmetros de la Bsqueda Tab: Criterio de parada: 10000 iteraciones Tamao de la lista tab: ndatos / 2. Tamao del vecindario: 30. N de iteraciones necesarias para reinicializar la bsqueda: 10 Tamao de la memoria a largo plazo: ndatos x ndatos (triangular superior). Criterio de aspiracin: vecino_generado_tabu < mejor_encontrada_hasta_ahora

PROCEDIMIENTO BusquedaTabu(): devuelve una solucion { nuevoTam:entero = tama * (tama - 1) / 2;

solucionesVecinas:array de enteros solucionesVecinas.reservar(numVecinos, array(tama) de enteros); mejorValorLocal: entero mejorSolucionActual:array(tam) de enteros

ListaTabu:array(tam,tam) de enteros ListaTabu.reservar(tamTabu, array(tama) de enteros)

pi:array(tama) de enteros solucionInicial(pi,tama,semilla)

mejorSoIucion=pi; mejorValor = coste(pi,Flujo,Dist,tama);

Para i = 0 Hasta i < numVecinos Hacer Para j = i + 1 Hasta j < tama Hacer frec[solucionesVecinas(i)(j))(solucionesVecinas(i)[j))=0 Fin_Para Fin_Para

contadorReinicio:entero

Para k = 0 Hasta k < numPasos Hacer -------------------------------------------------------------------------------- todasSolucionesVecinas:array(tam,tam) de enteros todasSolucionesVecinas.reasignar(nuevoTam, array de enteros) num:entero Repetir Para i = 0 Hasta i