Advanced algorithms and applicationslabsticc.univ-brest.fr/~lemarch/ENG/Cours/algoP2avanENG.pdf ·...
Transcript of Advanced algorithms and applicationslabsticc.univ-brest.fr/~lemarch/ENG/Cours/algoP2avanENG.pdf ·...
1
Advanced algorithms and applications
Laurent LemarchandLaurent LemarchandLISyC/UBOLISyC/UBO
[email protected]@univ-brest.fr
2
Dynamic Programmingprinciple (Bellman)
Decompose problem P into sub-problemsP
1, P
2, ..., P
n
Solve the sub problems to find the solutions v
1, v
2, ..., v
n
Combine these solutions to solve P :V* = f(v
1, v
2, ..., v
n)
Recursive mechanism
3
Dynamic programmingusage conditions
Optimality principle
Example : shortest paths : (A,B) is optimal iif (A,C) and (B,C) are also optimal.
A solution is optimal iff its subproblemsare also optimal
A B
C
4
Optimality principlecounterexample
Search of the shortest path of a given depth In this case you need to evaluate all intermediate
solutions
depth 1 depth 2
5
Dynamic programmingShortest path : Ford-Bellman
a g
f
e
d
c
b
Path finding : shortest path from a to one of its successors
Recursively : (s) = min s' preds(s)
(s') + ws' s
Other examples : Chortle-crf, resource allocation, inventory management ...
3
2
32
2
-2-11
245
2
6
Dynamic programmingEdition distance : Levenshtein metric
String metric for computing differences between 2 strings Number of edition operations to do for rewriting string A into B
Insertion: poe > pome Deletion: pome > ome Substitution: ome > ame
diff and agrep commands
poe to ame distanceis 3 – minimal ?
7
Dynamic programmingLevenshtein algorithm
algo Levenshtein
for i = 1 to n1 for j = 1 to n2 if str1[i-1] == str2[j-1] then cost = 0 else cost = 1 endif
d[i, j] := minimum( d[i-1, j ] + 1, // delete d[i, j-1] + 1, // insert d[i-1, j-1] + cost // substitute )
endfor endfor return d[n1, n2]end Levenshtein
input string str1[1..n1]string str2[1..n2]table d[n1+1,n2+1]
init d[0,0] = 0// if one string is null// dist = other's length i [1.. n1] d[i,0] = i j [1.. n2] d[0,j] = j
8
Dynamic programmingLevenshtein algorithm example
Firststep
…...............
Example : wikipedia
dist(NICHE to CHIEN) = 5
Computing d[i,j] Left + 1: d[i-1, j] + 1. (insert) Above +1: d[i, j-1] + 1 (delete) Diagonal : d[i-1,j-1]+ (0 or 1) substitution (if needed)
9
Branch and Bound methodsprinciple
All solutions implicit enumeration Search sub spaces S
1, S
2, ..., S
n
Quality of each sub space v(S1), v(S
2), ..., v(S
n)
S2S3
S1
S1 S2 S3
v S1
v S2
v S3
f s
10
Branch and Bound methodsprinciple
Let f(s) to be maximized An ever known feasible solution a
1, with v(a
1) = 12
v(S3) = 11 implies that we don't need to explore S
3
v(Si) is an upper bound on the quality of the feasible
solutions contained in Si
v S1
v S2
v S3
f s
a1
11
Branch and Bound methodsB&B algorithm
We also have an objective function, f(s) (max)
A partitionning function that splits a search space S into sub spaces :
S1, S
2, ..., S
n : S = U
n S
i
A quality evaluation function thats gives for a space an upper bound on the quality of its feasible solutions :
f : s S f(s*) v(S)
A search strategy to choose which is a next suub space Si to be
explorated at each step.
branch
bound
12
Branch and Bound methodssearch tree
The processing of the algorithm corresponds to the traversal of a search tree :
Each node represents a sub space
Leaves are feasible solutions or empty (without any feasible solution) sub spaces
Children S1, S
2, ..., S
n de S result of S
partitioning
13
Branch and Bound methodsalgorithm
Space S, Evaluation v(S)(min),split() next()node_list L = {S}Initial bound U = Best solution
Sbest
=
Algo B&Bwhile L do
S = next(L)S
1, S
2, ..., S
n= split(S)
foreach Si do
if v(Si) > U or S
i unfeasible
discard Si
else if Si feasible
Sbest
= Si
U = v(Si) (= f(S
i))
else L = L U {S
i}
end
14
Cuts within the search tree if v(Si) > U (if min)
Implicit enumeration
Branch and Bound methodscuts
1
2 5
43
16
18
= 25(U=25)
= 19(U=19)
20
Implicitlyenumerated
sub tree
15
Parallel algorithm Master/slave
// evaluation of nodes Centralized and distributed versions
Speedup results Positive or negative anomalies depending on the evaluation function and the search strategy
Bound update problem
Branch and Bound methodsparallelism
Slave 1
Slave 2
Slave 3
master
16
Example, centralized implemantation 1 master, 2 slaves, comms 1 time unit // ... Search tree traversal DFSsequential runtime of 7 time units
Branch and Bound methodsparallelism
1
2 7
63
16
18
22 = 19(U=19)
= 17(U=17)
18
54 = 23(U=23)
24
17
Branch and Bound methodsparallelism
1
2 2
16
18
= 17(U=17)
Speedup issuperlinear !
1
2 7
63
16
18
22 = 19(U=19)
= 17(U=17)
18
54 = 23(U=23)
24
+1 comm
Example, centralized implemantation 1 master, 2 slaves, comms 1 time unit // ... Search tree traversal DFSsequential runtime of 7 time units2 time units with 2 // procs
18
Branch and Bound methodsInteger programming example
Simplex method solves problems in ℝ How to solve it in ℕ ?
C1
C2 C3
S
x1
x2 x1+3x2⩽15−2x1−x2⩽−12−3x1−11x2⩽−66min 2x1+4x2
x1,x2∈ℝ
x1,x2 ∈ℕ
19
v(Sℝ) v(S
ℕ) since ℕ ℝ
Simplex provides a bound on the solution value in ℕ
We separate on variables bivalents (0-1 IP) Or in some integer interval (IP)
x1
x2
x3
0 1
1
1111
10 0
0000
Branch and Bound methodsInteger programming example
20
It was the first use of the B&B principle (Little algorithm)
Asymetric TSPproblem P
Branch and Bound applicationsTSP example
Exemple : Algorithme et Complexité #4 – c 2002 – Michel Van Caneghem
21
We substract each row its own minimum, and then apply the same operation to columnsproblem P2
Constants Don't change s
olutions ordering
z*(P) = z*(P2) + d
d = rows min(l) +colonms min(c)d = 16 + 3
Branch and Bound applicationsevaluation function
d is a lower bound
22
Branching : flavour on cheapest tours : 0 value edges.
Overcost if edge is excuded : starting from its initial node and going to its terminal … choose the most costly, expecting to cut it later ...
Branch and Bound applicationsbranching function
23
Delete row and column for positive branch, for backward edge (sub tour)
on the edge for negative branch
Branch and Bound applicationsone step
Final search tree
24
Find a tour t T of minimal length into some graph G = (V, E) Find a minimal spanning tree a A within graph G' = (V', E)
V' = V \ {V0}
Connect V0 to a in order to obtain a*' A'
Every tour t where an edge is deleted is a tree, so : T A' and t T, v(a*') v(t)
The algorithm that computes a*' gives a lower bound on the subspace T
Branch and Bound applicationsanother bound (MST)
25
Approximative result, but Sometimes only available method (e.g program optimization) Or exact methods for approximative model only (e.g circuit
testing) Usefullness
Combinatorial explosion Multiple or fuzzy objectives Variability (robustness) Fast runtimes more important than performance
Combinatorial OptimizationHeuristic methods
26
Greedy : build a solution step by step, they never come back on partial choices Often far from optimality
Very fast Local search improvement possible
Examples Knapsack Covering Maximum stable TSP
Combinatorial OptimizationGreedy methods
27
knapsack : fill a knapsack of limited weight, choosing the most interesting objects within a list
Linear program What mean variables
a1x1+ a2x2 ... + anxn bmax c1x1+ c2x2 ... + cnxn
xj j Xj ℕ
Order by profit c1 / a1 c2 / a2 ... cn / an
let x1 = min (1, b/a1) ; b = b - a1x1
Iterate on x2, x3, ..., xn
Greedy algorithmsKnapsack
28
Cover n elements by at least one object, each object has its own cost. Minimize total cost of chosen objects
A, covering matrix. What mean variables Aij
Aij 1
min c1x1 + c2x2 + … + cmxm
xj 1 and xj ℕ
Find k s.t ck/aj = min j 1..n cj/aj with aj = i=1..m Aij
Delete column k and rows such that Aik = 1
Iterate on reduced problem
Greedy algorithmsCovering
29
Closest Neighbourgh algorithm Random starting town
Go to next closest unvisited town
Loop from last to first town
Greedy algorithmsTravelling salesman probllem
30
Problem to face : go out local extrema Random exploration, even costly We have to focus on one solution
(convergency) Single solution evolution
Descent method Simulated annealing Tabu search
Or multiple solutions Genetic algorithm Ants
Neighborhood methods (local search)principle
z min
ok???
31
Define a neighborhood gunction V : S Sn
Provide a set of n solutions similar (close to) s S Explore these n solutions in order to find one that is better
than s
Sometimes non polynomial algorithm Optimality ?
Alternatively, search from a set of seed solutions
Local searchneighborhood
32
Objective function min f : S ℝ
Local search method V : S Sn
Provide a set of n solutions similar (close to) s S
generate an initial solution s0
s = s0
While end not reacheds' = min s V(s) f(s)
Local searchdescent
33
Example : 2-opt for TSP local search(Lin, 1965, n(n - 3)/2) Neighborhood of n2 tours
T' = T U { ik, j l } \ { i j, k l }
3-opt possible, but very large neighborhood n(n – 3)(n - 2)
Local searchTSP Problem
j
i l
kj
il
k
34
Graph G = (V, E) avec |X| = 2n find a partition X = V1 U V2 t.q |V1| = |V2| = n which minimizes the number of edges crossing the 2 parts Pairwise exchange neighborhood
Local search2-way Partitioning problem
a
b
c=7
a
b
c=5 = 7-3+1
35
At each step, choice the exchange maximizing the cut number gain Constraint : a node can be swapped only one time N/2 steps at most
2-way partitionningKernighan-Lin heuristic
36
Recall : trade off to find between Improving current solution Performing an efficient search of all the search space
Always the local extrema problem
Tradeoff
Improving descent methodspoints
z min
ok
???
Exploitation Exploration
37
Applicable to a lot of problems Dynamic evolution of the tradeoff exploit./explor. Based on crystal metal cooking model
Evolution of energy levels within the metal
Meta heuristicssimulated annealing (SA)
E(X)
X
temper annealingFast temperature
descent
Heating again
38
Simulated annealinganalogy physics/optimization
optimization
physics
39
First Explore randomly the search space
Vary the degree of non determism (temperature)
Start high level : exploration, with a very random behavior
End low level : exploitation as with descent methods
Simulated annealingprinciple
40
From current solution si, explore its neighborhood to obtain si+1
If f(si+1) – f(si) < 0, accept si+1 (minimisation)
Else, accept si+1 based on probality :
Simulated annealingone step
p sisi1=e− f si i−f si
T
Gibbs-Bolzmanndistribution
≈
41
Space S, Evaluation f(s)(min),temperature(T)accept(f,T)Initial temperature T = T0
Best solutions = sbest = greedy()
Algo SAwhile criteria1 do
while criteria2 do s2 = neighbor(s, S) f = f(s2) - f(s)
if f(s2) < f(sbest) sbest= s2
if f < 0 or accept(f, T) s = s2
endw
T = temperature(T)Endw End SA
Simulated annealingalgorithm
42
Population(Chromosomes)
Evaluation(fitness)
GeneticOperators
Manipulation
Newgeneration
Selection(groupement)
Parents
Reproduction
Genetic algorithmsOverview
43
Population
Set of individuals
Individuall
Encode a solution
Chromosome based representation
Chromosomes
Allele based
Genetic algorithmsData
00
1 a
cb
44
Population
Reproduction
duplication
Individual
Mutation
Crossing over
Genetic processingbased on chromosomes
a b
+
45
Space S, Evaluation f(s)(min),crossover(P)mutation(P)
Mutation and crossoverrates
Algo GAgenerate initial population P in Swhile end not reached do
reproduction(P) according to f() crossover(P)
mutation(P)endwBest solution within population end GA
Genetic algorithmsalgorithm
46
Population
For reproduction (roulette wheel)
Chances to be selected proportional to fitness Operations
Mutation rate example: 0,5%
Crossing over% of populationRandom cutting sites
Genetic processingramdom choices
i1
i2 i3
i4
Explorationof
the search space
Exploitationof
the search space
47
Empirical technique
Lot of freedom for Chromosome coding (building blocks)
Probabilities
Operators
Coupling witch others approaches
Parallelism
Genetic algorithmsimplementation
48
Different alternatives
Master/slave oriented, fine-grain model (// based on individual evaluation)
+ Local search applicable
Large grain approach (// based on the evolution of multiple independant populations)
Island model (with some individuals migrating from populations)
Genetic algorithmsparallelism
49
Benchmark TSPLIBhttp://www.iwr.uni-heidelberg.de/groups/comopt/software/TSPLIB95/index.html
2D instances (euclidian distances)
Island model, 10 stations, ethernet 100Mb/s, MPI (// interprocs)
1000 generations 1000 individuals Mutation 30%, (cross over ?) Circular migration, 100 iterations, 20% of population. 1 point Crossover, roulette whell selection
Genetic algorithmsparallelism - example
50
Genetic algorithmsparallelism - example
Comparison of Parallel Metaheuristics for Solving the TSPM. Lazarova, P. Borovska CompSysTech’08