Professional Documents
Culture Documents
METAHEURISTICA
BSQUEDA TAB
naferthd@uninorte.edu.co, landazuryf@uninorte.edu.co
Universidad del Norte
(TABU SEARCH)
I.
INTRODUCCIN
2
locales estn por tanto guiadas por informacin obtenida a lo
largo del proceso de bsqueda, la bsqueda tab contrasta con
diseos que por contra confan en procesos semialeatorios, que
implementan una forma de muestreo. La memoria adaptativa
tambin contrasta con los tpicos diseos de memoria rgidos
tales como las estrategias de ramificacin y acotacin. [3]
El nfasis en la exploracin responsiva considerada en la
bsqueda tab deriva de la suposicin de que una mala
eleccin estratgica puede proporcionar ms informacin que
una buena eleccin realizada al azar, dado que una eleccin
estratgica mala puede proporcionar pistas tiles sobre como
guiar la bsqueda hacia zonas prometedoras. Por lo tanto, la
exploracin responsiva integra los principios bsicos de la
bsqueda inteligente; explota las caractersticas de las
soluciones buenas a la vez que explora nuevas regiones
prometedoras.
II.
N
Suponga que se desea minimizar una funcin f (S) sobre
algn dominio y se aplica la versin mejor mejora de la
bsqueda tab, que corresponde a la versin en la cual se opta
en cada iteracin el mejor movimiento disponible.
1.
Inicializacin
Escoge (Construye) una solucin inicial S0.
Inicia S= S0, f*=f (S0), S*= S0, T=
2.
Bsqueda
Mientras el criterio de terminacin no sea satisfecho
hacer:
Selecciona S con el argmin [f(S)]; S
(S )
N
3
dentro del ovalo), encontrando de esta manera un ptimo local
para el vecindario de soluciones.
50
40
30
20
10
0
10 15 20 25 30 35 40 45 50
Ilustracin 1 Universo de soluciones
4
exhiban similar desempeo a las de las mejores soluciones.
Esto se logra a travs de restringir movimientos a soluciones
de menor desempeo.
Tal y como se ha descrito hasta el momento, el algoritmo
podra ser corrido, tericamente, de manera infinita, en la
prctica, la bsqueda tiene que ser terminada en un en el
tiempo que haga factible la obtencin, de si bien no el ptimo
global, una muy buena solucin. La culminacin del algoritmo
se realiza a travs de un criterio de terminacin, el cual
suspende el procedimiento luego de:
V.
APLICACIONES
j , j=1,2, , n
otro es:
n
c j( j)
j=1
Ciuda
1 2 n
d
c 11 c 12 c 1 n
1
c 21 c 22 c 2 n
2
cn 1
cn 2
c nn
5
punto i a otro j, sin tener en cuenta los obstculos que hacen
inviable transportarse de manera directa esa distancia.
Es normal encontrar en este tipo de problema que el costo, la
distancia o el tiempo representado en la tabla sea el mismo al
ir de una ciudad i a una j y viceversa.
B. Problema de Ruteo de Vehculos con Ventanas
de Tiempo.
Este problema es una variante de VRP conocida como
Problema de Ruteo de Vehculos con Ventanas de Tiempo
Parciales (Vehicle Routing Problem with Time Windows,
VRPTW).
A continuacin se definen los parmetros del problema en
cuestin:
En el problema VRPTW tenemos un conjunto de clientes
C={1, 2, ,n } , que residen en n ubicaciones
diferentes. Utilizamos el 0 para denotar la ubicacin del
depsito, con lo cual N=C U {0 } es el conjunto de
ubicaciones consideradas por el problema. A cada par de
clientes (i; j) , donde i, j , i j , se le asocia un
costo de viaje d ij > 0 y un tiempo de viaje t ij >0 .
Cada cliente i C
tiene una demanda w i > 0 . El
conjunto {d ij } define la matriz de costos del problema. La
matriz de costos satisface la desigualdad triangular si y solo si
d ik + d kj d ij i , j , k N . En nuestro caso, las instancias
del problema definen las ubicaciones de los clientes como
puntos en el plano y por lo tanto se definen los costos de viaje
como la distancia euclidiana entre los puntos. La matriz de
costos resultante es simtrica y satisface la desigualdad
triangular.
El conjunto de camiones o vehculos homogneos se denota
V , siendo m la capacidad de cada vehculo. En
algunas variantes del problema la cantidad de vehculos es una
variable a minimizar.
Ventana de Tiempo: Cada cliente i tiene una ventana de
tiempo o simplemente ventana, es decir, un intervalo
[ ai ; bi ] R donde ai y bi representan los horarios
de comienzo y el fin del abastecimiento del cliente i . Un
vehculo puede arribar a la ubicacin del cliente i antes de
ai , pero el abastecimiento no puede comenzar hasta el
horario de apertura de la
vehculo no puede arribar
finalizacin de la ventana
tambin tiene una ventana
a0
ai . Un
ventana de tiempo
al cliente i despus de la
de tiempo bi . El depsito
de tiempo [a0 ; b0 ] , donde
di
, la secuencia
depender
de la
Ti, j ,
la
wT T i
i
DESARROLLO EN MATLAB
10
11
12
13
29
10
26
20
26
22 10
18
17
28
22
30
17
17 23
12
30
17
29
11
27
14
20
13
26
10
25
30
13 20
14
11
24
15
7
5
26
22
11
25
10 23
11
17
10
20
30
27
17
16
25
26
17
30
15 27
21
29
30
22
17
13
10
15
24
24
10
23
14
20
23
17
27
15
20
10
18
12
20
14
21
10
13
15
11
17
13
11
11
24
10
30
14
12
28
30
24
17
16
29
15
13
30
13
17
26
15
10
25
30
24 20
15
14
0
1
12 13 3
1
0
11
147
10
11
12
13
29
10
26
20
26
22 10
18
17
28
22
30
17
17 23
12
30
17
29
11
27
14
20
13
26
10
25
30
13 20
14
11
24
15
26
22
11
25
10 23
11
17
10
20
30
27
17
16
25
26
17
30
15 27
21
29
30
22
17
13
10
15
24
24
10
23
14
20
23
17
27
15
20
10
18
12
20
14
21
10
13
15
11
17
13
11
11
24
10
30
14
12
28
30
24
17
16
29
15
13
30
13
17
26
15
10
25
30
24 20
15
14
F.O
1
0
1
0
1
0
1
0
1
0
1
0
1
0
12 13 3
13
13 12 4
13 12 3
13 12 3
13 12 3
13 12 3
13 12 3
10
13 12 3
13 12 3
11
123
11
109
11
121
11
119
11
90
11
94
11
89
11
73
11
10
97
11
75
8
[10]
[11]
[12]
ANEXO 1
A continuacin se muestra el cdigo en matlab para resolver
problemas del vendedor viajero a partir de la metaheuristica de
Bsqueda Tab.
% Problema del vendedor viajero usando Tabu
% Este algoritmo asume que la matriz de distancia es
simetrica
% El recorrido siempre incia desde el punto 1
clc
d = ['Insertar matriz de valores']
d_orig = d;
start_time = cputime;
dim1 = size(d,1);
dim12 = size(d);
for i=1:dim1
d(i,i)=10e+06;
end
%
*****************Inicializacion
de
parametros**********************
d1=d;
tour = zeros(dim12);
cost = 0;
min_dist=[ ];
short_path=[ ];
best_nbr_cost = 0;
best_nbr = [ ];
% *******Generar la solucion inicial -encontrar camino ms
corto desde cada nodo****
% Si se seleccionan los nodos 1-2, encontrar la distancia de 2
a cada uno de los nodos
k = 1;
for i=1:dim1-1
min_dist(i) = min(d1(k,:));
short_path(i) = find((d1(k,:)==min_dist(i)),1);
cost = cost+min_dist(i);
k = short_path(i);
% Prohibir todos los caminos desde el nodo actual visitado a
todos los nodos anteriores visitados
d1(k,1)=10e+06;
for visited_node = 1:length(short_path);
d1(k,short_path(visited_node))=10e+06;
end
end
tour(1,short_path(1))=1;
for i=2:dim1-1
tour(short_path(i-1),short_path(i))=1;
end
9
else
nbr_cost(crnt_tour(i),crnt_tour(j))=crnt_tour_costd(1,crnt_tour(i))+d(1,crnt_tour(j))d(crnt_tour(j),crnt_tour(j+1))+d(crnt_tour(i),crnt_tour(j+1))d(crnt_tour(i),crnt_tour(i+1))+d(crnt_tour(j),crnt_tour(i+1))d(crnt_tour(j-1),crnt_tour(j))+d(crnt_tour(j-1),crnt_tour(i));
end
else
if j-i==1
nbr_cost(crnt_tour(i),crnt_tour(j))=crnt_tour_costd(crnt_tour(i-1),crnt_tour(i))+d(crnt_tour(i-1),crnt_tour(j))d(crnt_tour(j),crnt_tour(j+1))+d(crnt_tour(i),crnt_tour(j+1));
else
nbr_cost(crnt_tour(i),crnt_tour(j))=crnt_tour_costd(crnt_tour(i-1),crnt_tour(i))+d(crnt_tour(i-1),crnt_tour(j))d(crnt_tour(j),crnt_tour(j+1))+d(crnt_tour(i),crnt_tour(j+1))d(crnt_tour(i),crnt_tour(i+1))+d(crnt_tour(j),crnt_tour(i+1))d(crnt_tour(j-1),crnt_tour(j))+d(crnt_tour(j-1),crnt_tour(i));
end
end
if nbr_cost(crnt_tour(i),crnt_tour(j)) < best_nbr_cost
best_nbr_cost = nbr_cost(crnt_tour(i),crnt_tour(j));
best_i=i;
best_j=j;
tabu_node1 = crnt_tour(i);
tabu_node2 = crnt_tour(j);
end
end
end
%*********** Aqui termina el calculo de los costos de los
vecinos***********
best_nbr(best_i) = crnt_tour(best_j);
best_nbr(best_j) = crnt_tour(best_i);
% **** Sustituya solucin actual por el mejor vecino.
*******************
% ************** Entrar en ella en la lista TABU
******************
% *** Nodos tab Etiqueta tal que nodo2 tab es siempre
mayor que tabu node1.
% Esto es necesario para mantener el carcter reciente basada
y frecuencia basado tabu la lista
% en la misma estructura de datos.
% ****** Encuentra el mejor vecino que no implique swaps
en la lista tab ***
% ************ Tomara la Respuesta tabu si se encuentra el
criterio de aspiracion **************
% ************** Se cumplen los criterios de aspiracin si
es un miembro de Tabu es mejor
% de la mejor solucin encontrada hasta el momento
**********************************
%, mientras que (tabu_tenure (tabu_node1, tabu_node2) |
tabu_tenure (tabu_node2, tabu_node1))> 0
while (tabu_tenure(tabu_node1,tabu_node2))>0
if best_nbr_cost < best_obj
%(TABU solution better than
the best found so far)
fprintf('\nbest nbr cost = %d\t and best obj = %d\n, hence
breaking',best_nbr_cost, best_obj);
break;
else
10
best_tour = crnt_tour;
iter_snc_last_imprv = 0;
else
iter_snc_last_imprv = iter_snc_last_imprv + 1;
%if iter_snc_last_imprv >= (dim1-1)*(dim1-2)/2
if iter_snc_last_imprv >= 400
fprintf('\n NO improvmennt since last % iterations, hence
diversify\n',iter_snc_last_imprv);
min_freq_col = min(frequency);
%gives minimum of
each column
min_freq = min(min_freq_col);
[R,C] = find((frequency==min_freq),1); %find the moves
with lowest frequency
freq_indx1 = R
freq_indx2 = C
indx_in_crnt_tour1 = find(crnt_tour==R); %locate the
moves in the crnt tour
indx_in_crnt_tour2 = find(crnt_tour==C);
%Diversify using a move that has the lowest frequency
temp = crnt_tour(indx_in_crnt_tour1);
crnt_tour(indx_in_crnt_tour1)
=
crnt_tour(indx_in_crnt_tour2);
crnt_tour(indx_in_crnt_tour2) = temp;
tabu_tenure = zeros(dim12);
frequency = zeros(dim12);
frequency(1,:)=100000;
frequency(:,1)=100000;
for i=1:dim1
frequency(i,i)=100000;
end
tabu_tenure(R,C)=max_tabu_tenure;
tabu_tenure(C,R)=max_tabu_tenure;
frequency(R,C)=frequency(R,C)+1;
frequency(C,R) = frequency(R,C);
%Re-calculare crnt tour cost
crnt_tour_cost = d(1,crnt_tour(1));
for i=1:dim1-1
crnt_tour_cost
crnt_tour_cost+d(crnt_tour(i),crnt_tour(i+1));
end
iter_snc_last_imprv = 0;
if crnt_tour_cost < best_obj
best_obj = crnt_tour_cost;
best_tour = crnt_tour;
end
end
end
%fprintf('\ncurrent tour\n')
%crnt_tour
fprintf('\ncurrent tour cost = %d\t', crnt_tour_cost);
%fprintf('\nbest tour\n');
%best_tour
fprintf('best obj =%d\t',best_obj);
%pause;
End
fprintf('\nbest tour\n');
best_tour
fprintf('best obj =%d\n',best_obj);
end_time = cputime;
exec_time = end_time - start_time;
fprintf('\ntime taken = %f\t', exec_time);