Derniers messages sur Zeste de Savoirhttps://zestedesavoir.com/forums/2015-10-03T16:16:49+02:00Les derniers messages parus sur le forum de Zeste de Savoir.Optimisation de recuit simulé pour le problème du voyageur, message #760062015-10-03T16:16:49+02:00anonyme/@anonymehttps://zestedesavoir.com/forums/sujet/3867/optimisation-de-recuit-simule-pour-le-probleme-du-voyageur/?page=1#p76006<p>Juste une petite mise à jour pour vous montrer un graphique que j'ai fait sur l'amélioration par algorithme glouton. SA c'est le recuit simulé et SA+GA c'est recuit simulé avec recherche gloutonne après. C'est un <em>violin plot</em>, ça permet de voir la densité de probabilité en plus du reste des informations d'une simple boîte à moustaches. J'obtiens ceci:</p>
<p><img alt="" src="http://i.imgur.com/YlWYJ2p.png"></p>
<p>C'est assez parlant je trouve. Il faudrait que je fasse un autre graphique avec les delta.</p>Optimisation de recuit simulé pour le problème du voyageur, message #697882015-08-17T11:12:21+02:00anonyme/@anonymehttps://zestedesavoir.com/forums/sujet/3867/optimisation-de-recuit-simule-pour-le-probleme-du-voyageur/?page=1#p69788<p>J'essaierai le refroidissement logarithmique quand j'aurai fini la recherche gloutonne. En tout cas, j'apprécie beaucoup votre aide !</p>
<p><em>EDIT:</em></p>
<p>J'ai implémenté la recherche gloutonne. C'est assez efficace et parfois ça donne de très très bons résultats:</p>
<table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1
2
3
4
5</pre></div></td><td class="code"><div class="codehilite"><pre>λ ./travelingsalesman.py test.txt 50 0.001
Best: 319.0 for [9, 7, 11, 13, 2, 6, 14, 8, 4, 1, 12, 0, 10, 3, 5]
Worst: 395.0 for [11, 2, 6, 4, 1, 8, 7, 14, 12, 0, 10, 9, 13, 5, 3]
Average: 367.27
Greedy local search gives 268.0 for [7, 9, 13, 11, 2, 6, 4, 8, 14, 1, 12, 0, 10, 3, 5]
</pre></div>
</td></tr></table>
<p>Voilà le code modifié:</p>
<div class="spoiler">
<p><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119</pre></div></td><td class="code"><div class="codehilite"><pre><span class="c">#!/usr/bin/python2 -u</span>
<span class="c"># The -u flag is very important, as it prevents output buffering</span>
<span class="kn">import</span> <span class="nn">random</span><span class="o">,</span> <span class="nn">math</span><span class="o">,</span> <span class="nn">csv</span><span class="o">,</span> <span class="nn">sys</span><span class="o">,</span> <span class="nn">itertools</span><span class="o">,</span> <span class="nn">time</span>
<span class="k">class</span> <span class="nc">TSP</span><span class="p">:</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">distancematrix</span><span class="p">):</span>
<span class="sd">""" distancematrix is a matrix of size N*N, giving the distance between two cities</span>
<span class="sd"> A matrix allows us to have different distances from A to B than from B to A, but that wouldn't make sense.</span>
<span class="sd"> Hence we'll use an upper triangular matrix, the rest of the values are undefined and we don't care about them """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">distances</span> <span class="o">=</span> <span class="n">distancematrix</span>
<span class="bp">self</span><span class="o">.</span><span class="n">size</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">distances</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> <span class="c"># Number of cities</span>
<span class="k">def</span> <span class="nf">stillaccept</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">rdist</span><span class="p">,</span><span class="n">sdist</span><span class="p">,</span><span class="n">t</span><span class="p">):</span>
<span class="k">return</span> <span class="n">random</span><span class="o">.</span><span class="n">random</span><span class="p">()</span> <span class="o"><</span> <span class="n">math</span><span class="o">.</span><span class="n">exp</span><span class="p">((</span><span class="n">rdist</span> <span class="o">-</span> <span class="n">sdist</span><span class="p">)</span><span class="o">/</span><span class="n">t</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">tweak</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">solution</span><span class="p">):</span>
<span class="sd">""" Swap two random cities """</span>
<span class="n">solution</span> <span class="o">=</span> <span class="n">solution</span><span class="p">[::]</span> <span class="c"># Copy solution</span>
<span class="n">i</span><span class="p">,</span><span class="n">j</span> <span class="o">=</span> <span class="n">random</span><span class="o">.</span><span class="n">sample</span><span class="p">(</span><span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">solution</span><span class="p">)),</span> <span class="mi">2</span><span class="p">)</span>
<span class="n">solution</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="n">solution</span><span class="p">[</span><span class="n">j</span><span class="p">]</span> <span class="o">=</span> <span class="n">solution</span><span class="p">[</span><span class="n">j</span><span class="p">],</span> <span class="n">solution</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
<span class="k">return</span> <span class="n">solution</span>
<span class="k">def</span> <span class="nf">totaldistance</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span><span class="n">solution</span><span class="p">):</span>
<span class="k">return</span> <span class="nb">sum</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">distances</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">j</span><span class="p">]</span> <span class="k">for</span> <span class="n">i</span><span class="p">,</span> <span class="n">j</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">(</span><span class="n">solution</span><span class="p">,</span> <span class="n">solution</span><span class="p">[</span><span class="mi">1</span><span class="p">:]))</span>
<span class="k">def</span> <span class="nf">seed_solution</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="n">s</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">distances</span><span class="p">[</span><span class="mi">0</span><span class="p">])))</span>
<span class="n">random</span><span class="o">.</span><span class="n">shuffle</span><span class="p">(</span><span class="n">s</span><span class="p">)</span>
<span class="k">return</span> <span class="n">s</span>
<span class="k">class</span> <span class="nc">SimulatedAnnealing</span><span class="p">:</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">problem</span><span class="p">,</span> <span class="n">coolingrate</span><span class="p">,</span> <span class="n">inittemp</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">pb</span> <span class="o">=</span> <span class="n">problem</span>
<span class="bp">self</span><span class="o">.</span><span class="n">cRate</span> <span class="o">=</span> <span class="n">coolingrate</span>
<span class="bp">self</span><span class="o">.</span><span class="n">initT</span> <span class="o">=</span> <span class="n">inittemp</span>
<span class="k">def</span> <span class="nf">run</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="n">pb</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">pb</span>
<span class="n">s</span> <span class="o">=</span> <span class="n">pb</span><span class="o">.</span><span class="n">seed_solution</span><span class="p">()</span>
<span class="n">best</span> <span class="o">=</span> <span class="n">s</span>
<span class="n">bestdistance</span> <span class="o">=</span> <span class="n">pb</span><span class="o">.</span><span class="n">totaldistance</span><span class="p">(</span><span class="n">s</span><span class="p">)</span>
<span class="n">sdist</span> <span class="o">=</span> <span class="n">bestdistance</span>
<span class="n">t</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">initT</span>
<span class="k">while</span> <span class="n">t</span> <span class="o">></span> <span class="mi">1</span><span class="p">:</span>
<span class="n">r</span> <span class="o">=</span> <span class="n">pb</span><span class="o">.</span><span class="n">tweak</span><span class="p">(</span><span class="n">s</span><span class="p">)</span>
<span class="n">rdist</span> <span class="o">=</span> <span class="n">pb</span><span class="o">.</span><span class="n">totaldistance</span><span class="p">(</span><span class="n">r</span><span class="p">)</span>
<span class="k">if</span> <span class="n">rdist</span> <span class="o"><</span> <span class="n">sdist</span> <span class="ow">or</span> <span class="n">pb</span><span class="o">.</span><span class="n">stillaccept</span><span class="p">(</span><span class="n">rdist</span><span class="p">,</span><span class="n">sdist</span><span class="p">,</span><span class="n">t</span><span class="p">):</span>
<span class="n">s</span> <span class="o">=</span> <span class="n">r</span>
<span class="n">sdist</span> <span class="o">=</span> <span class="n">rdist</span>
<span class="n">t</span> <span class="o">*=</span> <span class="mi">1</span><span class="o">-</span><span class="bp">self</span><span class="o">.</span><span class="n">cRate</span> <span class="c"># Cool system</span>
<span class="k">if</span> <span class="n">rdist</span> <span class="o"><</span> <span class="n">bestdistance</span><span class="p">:</span>
<span class="n">best</span> <span class="o">=</span> <span class="n">r</span>
<span class="n">bestdistance</span> <span class="o">=</span> <span class="n">rdist</span>
<span class="k">return</span> <span class="n">best</span><span class="p">,</span> <span class="n">bestdistance</span>
<span class="k">class</span> <span class="nc">GreedyLocalSearch</span><span class="p">:</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">problem</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">pb</span> <span class="o">=</span> <span class="n">problem</span>
<span class="k">def</span> <span class="nf">swap</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">s</span><span class="p">,</span> <span class="n">swap</span><span class="p">):</span>
<span class="n">i</span> <span class="o">=</span> <span class="n">swap</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="n">j</span> <span class="o">=</span> <span class="n">swap</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
<span class="n">s</span> <span class="o">=</span> <span class="n">s</span><span class="p">[::]</span>
<span class="n">s</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="n">s</span><span class="p">[</span><span class="n">j</span><span class="p">]</span> <span class="o">=</span> <span class="n">s</span><span class="p">[</span><span class="n">j</span><span class="p">],</span> <span class="n">s</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
<span class="k">return</span> <span class="n">s</span>
<span class="k">def</span> <span class="nf">bestNeighbor</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">s</span><span class="p">,</span> <span class="n">sdist</span><span class="p">):</span>
<span class="c"># Yield better neighbor</span>
<span class="n">size</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">s</span><span class="p">)</span>
<span class="n">possibleSwaps</span> <span class="o">=</span> <span class="n">itertools</span><span class="o">.</span><span class="n">product</span><span class="p">(</span><span class="nb">range</span><span class="p">(</span><span class="n">size</span><span class="p">),</span> <span class="nb">range</span><span class="p">(</span><span class="n">size</span><span class="p">))</span>
<span class="n">best</span> <span class="o">=</span> <span class="n">s</span>
<span class="n">bdist</span> <span class="o">=</span> <span class="n">sdist</span>
<span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="n">possibleSwaps</span><span class="p">:</span>
<span class="n">new</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">swap</span><span class="p">(</span><span class="n">best</span><span class="p">,</span> <span class="n">x</span><span class="p">)</span>
<span class="n">newdist</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">pb</span><span class="o">.</span><span class="n">totaldistance</span><span class="p">(</span><span class="n">new</span><span class="p">)</span>
<span class="k">if</span> <span class="n">newdist</span> <span class="o"><</span> <span class="n">bdist</span><span class="p">:</span>
<span class="n">best</span> <span class="o">=</span> <span class="n">new</span><span class="p">;</span> <span class="n">bdist</span> <span class="o">=</span> <span class="n">newdist</span>
<span class="k">return</span> <span class="n">best</span><span class="p">,</span> <span class="n">bdist</span>
<span class="k">def</span> <span class="nf">run</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">seed</span><span class="p">):</span>
<span class="n">pb</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">pb</span>
<span class="n">size</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">seed</span><span class="p">)</span>
<span class="n">best</span> <span class="o">=</span> <span class="n">seed</span>
<span class="n">bdist</span> <span class="o">=</span> <span class="n">pb</span><span class="o">.</span><span class="n">totaldistance</span><span class="p">(</span><span class="n">seed</span><span class="p">)</span>
<span class="n">new</span><span class="p">,</span> <span class="n">newdist</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">bestNeighbor</span><span class="p">(</span><span class="n">best</span><span class="p">,</span> <span class="n">bdist</span><span class="p">)</span>
<span class="k">while</span> <span class="n">new</span> <span class="o">!=</span> <span class="n">best</span> <span class="ow">and</span> <span class="n">newdist</span> <span class="o">!=</span> <span class="n">bdist</span><span class="p">:</span> <span class="c"># Loop while there is a better neighbor</span>
<span class="n">best</span><span class="p">,</span> <span class="n">bdist</span> <span class="o">=</span> <span class="n">new</span><span class="p">,</span> <span class="n">newdist</span>
<span class="n">new</span><span class="p">,</span> <span class="n">newdist</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">bestNeighbor</span><span class="p">(</span><span class="n">best</span><span class="p">,</span> <span class="n">bdist</span><span class="p">)</span>
<span class="k">return</span> <span class="n">best</span><span class="p">,</span> <span class="n">bdist</span>
<span class="n">strmat</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">csv</span><span class="o">.</span><span class="n">reader</span><span class="p">(</span><span class="nb">open</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">argv</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="s">"r"</span><span class="p">),</span> <span class="n">delimiter</span><span class="o">=</span><span class="s">','</span><span class="p">))</span>
<span class="n">matrix</span> <span class="o">=</span> <span class="p">[</span> <span class="nb">map</span><span class="p">(</span><span class="nb">float</span><span class="p">,</span> <span class="n">strmat</span><span class="p">[</span><span class="n">i</span><span class="p">])</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">strmat</span><span class="p">))</span> <span class="p">]</span>
<span class="n">tsp</span> <span class="o">=</span> <span class="n">TSP</span><span class="p">(</span><span class="n">matrix</span><span class="p">)</span>
<span class="n">sa</span> <span class="o">=</span> <span class="n">SimulatedAnnealing</span><span class="p">(</span><span class="n">tsp</span><span class="p">,</span> <span class="nb">float</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">argv</span><span class="p">[</span><span class="mi">3</span><span class="p">]),</span> <span class="mi">10</span><span class="o">**</span><span class="nb">float</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">argv</span><span class="p">[</span><span class="mi">2</span><span class="p">]))</span>
<span class="n">bestsol</span><span class="p">,</span> <span class="n">bestdist</span> <span class="o">=</span> <span class="n">sa</span><span class="o">.</span><span class="n">run</span><span class="p">()</span>
<span class="n">worstsol</span><span class="p">,</span> <span class="n">worstdist</span> <span class="o">=</span> <span class="n">bestsol</span><span class="p">,</span> <span class="n">bestdist</span>
<span class="n">mean</span> <span class="o">=</span> <span class="n">bestdist</span><span class="o">/</span><span class="mi">100</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">99</span><span class="p">):</span>
<span class="n">newsol</span><span class="p">,</span> <span class="n">newdist</span> <span class="o">=</span> <span class="n">sa</span><span class="o">.</span><span class="n">run</span><span class="p">()</span>
<span class="n">mean</span> <span class="o">+=</span> <span class="n">newdist</span><span class="o">/</span><span class="mi">100</span>
<span class="k">if</span> <span class="n">newdist</span> <span class="o"><</span> <span class="n">bestdist</span><span class="p">:</span>
<span class="n">bestsol</span> <span class="o">=</span> <span class="n">newsol</span>
<span class="n">bestdist</span> <span class="o">=</span> <span class="n">newdist</span>
<span class="k">if</span> <span class="n">newdist</span> <span class="o">></span> <span class="n">worstdist</span><span class="p">:</span>
<span class="n">worstsol</span> <span class="o">=</span> <span class="n">newsol</span>
<span class="n">worstdist</span> <span class="o">=</span> <span class="n">newdist</span>
<span class="k">print</span><span class="p">(</span><span class="s">"Best: {} for {}"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">bestdist</span><span class="p">,</span> <span class="n">bestsol</span><span class="p">))</span>
<span class="k">print</span><span class="p">(</span><span class="s">"Worst: {} for {}"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">worstdist</span><span class="p">,</span> <span class="n">worstsol</span><span class="p">))</span>
<span class="k">print</span><span class="p">(</span><span class="s">"Average: {}"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">mean</span><span class="p">))</span>
<span class="c"># Now that we have a good solution, let's apply greedy local search to it</span>
<span class="n">greedy</span> <span class="o">=</span> <span class="n">GreedyLocalSearch</span><span class="p">(</span><span class="n">tsp</span><span class="p">)</span>
<span class="n">best</span><span class="p">,</span> <span class="n">bdist</span> <span class="o">=</span> <span class="n">greedy</span><span class="o">.</span><span class="n">run</span><span class="p">(</span><span class="n">bestsol</span><span class="p">)</span>
<span class="k">print</span><span class="p">(</span><span class="s">"Greedy local search gives {} for {}"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">bdist</span><span class="p">,</span> <span class="n">best</span><span class="p">))</span>
</pre></div>
</td></tr></table>
</p>
</div>Optimisation de recuit simulé pour le problème du voyageur, message #697852015-08-17T11:01:20+02:00KFC/@KFChttps://zestedesavoir.com/forums/sujet/3867/optimisation-de-recuit-simule-pour-le-probleme-du-voyageur/?page=1#p69785<p>Je n'avais pas vu l'etoile devant le signe egal. Ce qui de toute maniere n'aurait pas eu de sens. J'ai lu trop vite. Ceci dit, la remarque reste valide. <img alt=":)" src="/static/smileys/smile.png"></p>Optimisation de recuit simulé pour le problème du voyageur, message #697782015-08-17T10:38:03+02:00anonyme/@anonymehttps://zestedesavoir.com/forums/sujet/3867/optimisation-de-recuit-simule-pour-le-probleme-du-voyageur/?page=1#p69778<figure><blockquote>
<p>Dans un premier temps, je te conseille de travailler sur ton <em>cooling schedule</em>. Ici tu as un <em>cooling</em> arithmétique qui est rarement, en pratique, le plus efficace, par rapport à un <em>cooling</em> géométrique de type <span>$T_n = \beta T_{n-1}$</span> pour un <span>$\beta \in ]0,1[$</span>. <br>
Tu peux également tester un <em>cooling</em> logarithmique de type <span>$T_n = \frac{T_0}{(n-1)^2}$</span> assez utilisé aussi.</p>
</blockquote>
<figcaption><p><a href="http://zestedesavoir.com/forums/sujet/3867/optimisation-de-recuit-simule-pour-le-probleme-du-voyageur/?page=1#p69747">Höd</a></p></figcaption></figure><p>Pourtant quand je fais le refroidissement, je fais <code>t *= 1-coolingrate</code>, pour moi c'est géométrique.</p>
<p>D'ailleurs, j'ai retapé mon code en m'inspirant fortement des modifications de yoch, et je trouve la même chose que lui maintenant. Je vais tenter d'ajouter la recherche locale à la fin vu que ça a l'air de bien améliorer les résultats.</p>Optimisation de recuit simulé pour le problème du voyageur, message #697552015-08-17T00:04:02+02:00yoch/@yochhttps://zestedesavoir.com/forums/sujet/3867/optimisation-de-recuit-simule-pour-le-probleme-du-voyageur/?page=1#p69755<figure><blockquote>
<p>Pour la condition d’arrêt je pensais juste à expliciter la liste des voisins à chaque itérations (il y a <span>$n(n-1)$</span> voisins différents possibles), et à sélectionner le meilleur. C'est un algorithme glouton, qui ressemble à un <a href="https://en.wikipedia.org/wiki/Hill_climbing">hill climbing</a>. Ton algorithme s'arrête uniquement lorsqu'il n'existe aucun voisin immédiat avec un meilleur trajet. Ainsi tu es sûr d'arriver assez vite dans un optimum <strong>local</strong> (pas <strong>global</strong>). </p>
</blockquote>
<figcaption><p><a href="http://zestedesavoir.com/forums/sujet/3867/optimisation-de-recuit-simule-pour-le-probleme-du-voyageur/?page=1#p69742">Algue-Rythme</a></p></figcaption></figure><p>J'ai testé, il y a un gain de 30 points en moyenne, donc oui c'est intéressant !</p>
<p>Exemple de solution (longueur: 268) :</p>
<table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1</pre></div></td><td class="code"><div class="codehilite"><pre>[12, 1, 14, 8, 4, 6, 2, 11, 13, 9, 7, 5, 3, 10, 0]
</pre></div>
</td></tr></table>Optimisation de recuit simulé pour le problème du voyageur, message #697472015-08-16T23:44:28+02:00KFC/@KFChttps://zestedesavoir.com/forums/sujet/3867/optimisation-de-recuit-simule-pour-le-probleme-du-voyageur/?page=1#p69747<p>Dans un premier temps, je te conseille de travailler sur ton <em>cooling schedule</em>. Ici tu as un <em>cooling</em> arithmétique qui est rarement, en pratique, le plus efficace, par rapport à un <em>cooling</em> géométrique de type <span>$T_n = \beta T_{n-1}$</span> pour un <span>$\beta \in ]0,1[$</span>. <br>
Tu peux également tester un <em>cooling</em> logarithmique de type <span>$T_n = \frac{T_0}{(n-1)^2}$</span> assez utilisé aussi.</p>
<p>En règle général, le gros problème est toujours le <em>parameter tuning</em> sur ce genre de méthodes approchées. Du coup, pour vraiment calibrer et tirer le meilleur de ton algorithme sur ce problème particulier (tu ne réussiras pas à avoir un bon algorithme sur un gros ensemble de problèmes ou d'instances : <em>No Free Lunch Theorem</em>), tu n'as pas le choix :</p>
<ul>
<li>Plan d'expérience</li>
<li>Analyse de variance (ANOVA)</li>
<li>Optimisation <em>offline</em> automatique via un <em>framework</em> comme ParamILS</li>
</ul>
<p>Quelque chose de plus intérêt pour toi et pour l'exercice serait de te tourner vers de l'optimisation <em>online</em> de paramètres, qui lorsque les stratégies sont bien conçues, <em>outperforms</em> toujours des stratégies hors ligne ou statique. Par ailleurs,<a href="https://hal.inria.fr/inria-00140549/document"> ces stratégies sont bien plus dans l'esprit dynamique de ces méthodes stochastiques</a>. </p>Optimisation de recuit simulé pour le problème du voyageur, message #697422015-08-16T22:27:40+02:00Algue-Rythme/@Algue-Rythmehttps://zestedesavoir.com/forums/sujet/3867/optimisation-de-recuit-simule-pour-le-probleme-du-voyageur/?page=1#p69742<blockquote>
<p>Je vais me pencher sur la fonction <code>tweak()</code> du coup. Ton papier m'intéresse, ça m'aiderait sans doute à visualiser les possibilités de mutations. </p>
</blockquote>
<p>Voici <a href="http://labo.algo.free.fr/pvc/algorithme_genetique.html">l'article d'origine</a>. </p>
<p>Ce n'est pas beaucoup plus détaillé que ma citation pour les parties qui t'intéressent. Je n'arrive plus à retrouver les sources qui détaillent la dernière méthode. </p>
<blockquote>
<p>Ca tourne en boucle infinie pour l'instant, mais je pourrais faire en sorte de l'arrêter quand je suis suffisamment proche des 300km. Est-ce que c'était ça ce que tu voulais dire ? </p>
</blockquote>
<p>J'ai du mal à comprendre ce que fait exactement ton code, désolé. Pour la condition d’arrêt je pensais juste à expliciter la liste des voisins à chaque itérations (il y a <span>$n(n-1)$</span> voisins différents possibles), et à sélectionner le meilleur. C'est un algorithme glouton, qui ressemble à un <a href="https://en.wikipedia.org/wiki/Hill_climbing">hill climbing</a>. Ton algorithme s'arrête uniquement lorsqu'il n'existe aucun voisin immédiat avec un meilleur trajet. Ainsi tu es sûr d'arriver assez vite dans un optimum <strong>local</strong> (pas <strong>global</strong>). </p>Optimisation de recuit simulé pour le problème du voyageur, message #697412015-08-16T22:18:40+02:00anonyme/@anonymehttps://zestedesavoir.com/forums/sujet/3867/optimisation-de-recuit-simule-pour-le-probleme-du-voyageur/?page=1#p69741<p>J'ai mis <code>random.sample</code> dans ma fonction tweak mais j'ai toujours cette différence. c'est vraiment bizarre, il faut que je regarde ça de plus près. Sinon, je dois te dire que je préfère de loin ton code <img alt=":D" src="/static/smileys/heureux.png"></p>Optimisation de recuit simulé pour le problème du voyageur, message #697392015-08-16T21:44:35+02:00yoch/@yochhttps://zestedesavoir.com/forums/sujet/3867/optimisation-de-recuit-simule-pour-le-probleme-du-voyageur/?page=1#p69739<p>C'est très curieux. Je viens de tester avec 0.001 sur 100 essais, et j'obtiens :</p>
<ul>
<li>min : 328</li>
<li>max : 396</li>
<li>avg : 367.5</li>
<li>std : 14</li>
</ul>
<p>L'écart me semble beaucoup trop grand pour être explicable simplement. La seule différence notable est que j'utilise python3, mais je ne vois pas pourquoi ça aurait une influence (peut-être un autre type de random ?).</p>
<p>Si tu veux, <a href="http://paste.awesom.eu/yoch/vku6">voici</a> ton code source que j'ai modifié à ma sauce (mais sans toucher à l'algo, en principe).</p>
<p>EDIT: Ah, en fait il y a une petite différence au niveau du tweak: dans ton cas, il y a une légère probabilité qu'il renvoie la même solution.</p>Optimisation de recuit simulé pour le problème du voyageur, message #697372015-08-16T21:23:34+02:00anonyme/@anonymehttps://zestedesavoir.com/forums/sujet/3867/optimisation-de-recuit-simule-pour-le-probleme-du-voyageur/?page=1#p69737<p>Ouais je me suis planté, c'était 50 et 0.1. J'ai fait un nouveau benchmark avec 1000 essais et pour une température de <span>$10^{50}$</span>:</p>
<div class="table-wrapper">
<table>
<thead>
<tr>
<th>Taux de refroidissement</th>
<th>Minimum</th>
<th>Maximum</th>
<th>Moyenne</th>
</tr>
</thead>
<tbody>
<tr>
<td>O.1</td>
<td>347</td>
<td>608</td>
<td>517.203</td>
</tr>
<tr>
<td>0.01</td>
<td>337</td>
<td>517</td>
<td>456.453</td>
</tr>
<tr>
<td>0.001 pour le fun</td>
<td>318</td>
<td>462</td>
<td>414.367</td>
</tr>
</tbody>
</table>
</div>
<p>C'est marrant, je trouve un maximum et une moyenne bien plus élevés que toi pour 0.01. Par contre 0.001 c'est bien trop lent même si ça donne de très bon résultats.</p>Optimisation de recuit simulé pour le problème du voyageur, message #697322015-08-16T20:51:54+02:00yoch/@yochhttps://zestedesavoir.com/forums/sujet/3867/optimisation-de-recuit-simule-pour-le-probleme-du-voyageur/?page=1#p69732<blockquote>
<p>Pour faire tourner ce code, il faut faire <code>./tsp.py <fichier csv> <exposant de la température> <taux de refroidissement></code> (j'ai mis respectivement 0.50 et 0.1 pour les tests je crois). Si vous voulez que j'explique plus comment j'ai procédé, dites-le vu que je commente très peu.</p>
</blockquote>
<p>J'imagine que tu veux dire 50.0 et 0.1, non ?</p>
<p>A ta place, je prendrai 0.01. Avec ce réglage, j'obtiens ces stats (sur 100 essais) :</p>
<ul>
<li>min : 341</li>
<li>max : 429</li>
<li>avg : 394.5</li>
</ul>
<figure><blockquote>
<p>Maintenant, je voudrais améliorer encore les performances, autrement qu'en modifiant température et taux de refroidissement, car la valeur moyenne de 433 km est franchement éloignée des 300 km presque optimaux. La page Wikipédia suggère de faire des redémarrages, mais qu'est-ce que je peux faire d'autre pour améliorer l'algo ou le code ?</p>
</blockquote>
<figcaption><p><a href="http://zestedesavoir.com/forums/sujet/3867/optimisation-de-recuit-simule-pour-le-probleme-du-voyageur/?page=1#p69717">Grimur</a></p></figcaption></figure><p>L'essentiel de l'optimisation de ce genre d'algo repose justement sur le choix des paramètres, tu va avoir du mal à faire autrement. Sinon, ton code est certainement améliorable, mais le seul impact sera sur la vitesse d’exécution (et encore je ne sais pas combien on peut gagner), pas sur la qualité des solutions.</p>
<p>Pour les autres astuces possibles, je n'en connais pas en particulier, mais je ne suis absolument pas expert. Tu pourrais par exemple essayer une décroissance linéaire de la température.</p>
<p>Pour la corrélation avec les algos génétiques, attention quand même: en SA il faut un solution <strong>voisine</strong>, ce qui n'est pas forcément toujours le cas avec les mutation génétiques (où le but est de combiner des génomes, et pas de trouver une solution proche).</p>Optimisation de recuit simulé pour le problème du voyageur, message #697272015-08-16T20:03:34+02:00anonyme/@anonymehttps://zestedesavoir.com/forums/sujet/3867/optimisation-de-recuit-simule-pour-le-probleme-du-voyageur/?page=1#p69727<p>Je vais me pencher sur la fonction <code>tweak()</code> du coup. Ton papier m'intéresse, ça m'aiderait sans doute à visualiser les possibilités de mutations.</p>
<p>En fait le 1 c'est un nombre parfaitement pifométrique pour décider quand arrêter. Comme j'ai remarqué que les solutions sont rarement très bonnes, j'ai une étape qui correspondrait peut-être à ce que tu appelles recherche locale:</p>
<table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1
2
3
4
5
6
7</pre></div></td><td class="code"><div class="codehilite"><pre>bestsol, bestdist = tsp.simulated_annealing(10**float(sys.argv[2]), float(sys.argv[3]))
while True:
newsol, newdist = tsp.simulated_annealing(float(sys.argv[2]), float(sys.argv[3]))
if newdist < bestdist:
bestsol = newsol
bestdist = newdist
print("[{}] Best distance so far: {} for {}".format(time.strftime("%H:%M"),bestdist, bestsol))
</pre></div>
</td></tr></table>
<p>Ca tourne en boucle infinie pour l'instant, mais je pourrais faire en sorte de l'arrêter qund je suis suffisamment proche des 300km. Est-ce que c'était ça ce que tu voulais dire ?</p>Optimisation de recuit simulé pour le problème du voyageur, message #697242015-08-16T19:42:59+02:00Algue-Rythme/@Algue-Rythmehttps://zestedesavoir.com/forums/sujet/3867/optimisation-de-recuit-simule-pour-le-probleme-du-voyageur/?page=1#p69724<p>Je ne suis pas très bon en Python, donc je ne pourrais pas t'aider sur l'examen du code en détail, toutefois je ferais de mon mieux pour le reste. </p>
<p>Ton choix de voisinage (l'échange de deux villes) me semble pertinent. Toutefois, j'avais vu un papier qui traitait des mutations à appliquer à une solution de ce problème dans le cas où on tentait de le résoudre par des algorithmes génétiques, et les mutations d'un algorithme génétique ressemblent souvent à la notion de voisinage d'un recuit simulé. </p>
<p>Voici quelles étaient les mutations ( = relations de voisinage) proposées : </p>
<blockquote>
<ul>
<li>Echange de deux villes </li>
<li>Renversement de parcours entre deux villes (assez efficace en particulier s'il est appliqué parfois deux ou trois fois à la suite) </li>
<li>Remplacement d'une liaison entre deux villes par une liaison entre la première ville et la ville la plus proche </li>
<li>"Double bridge" ou 4-change non séquentiel : le parcours : <span>$0 ... i i+1 ... j j+1 ... k k+1 ... l l+1 ...$</span> est modifié en : <span>$0...i k+1 ... l j+1 ... k i+1 ... j l+1 ...$</span>
i et k ainsi que j et l peuvent être proche pour plus d'efficacité (assez efficace) </li>
</ul>
</blockquote>
<p>Dans la pratique, il me semble que la dernière option, qui n'est pas la plus évidente à mettre en œuvre (mais bon ça reste faisable), demeure l'une des plus utilisées dans le milieu et elle donne souvent de bons résultats. </p>
<p>Une dernière question : es-tu sûr, lorsque la température atteint 1, que ta solution est dans le minimum local, ou n'y-a-t-il pas une chance que quelques itérations gloutonnes déterministes supplémentaires puissent l'améliorer ?<br>
Si ce n'est pas le cas, lancer une recherche locale à la suite du recuit simulé peut servir à améliorer substantiellement la solution. </p>Optimisation de recuit simulé pour le problème du voyageur, message #697172015-08-16T18:32:35+02:00anonyme/@anonymehttps://zestedesavoir.com/forums/sujet/3867/optimisation-de-recuit-simule-pour-le-probleme-du-voyageur/?page=1#p69717<p>Bonjour tout le monde,</p>
<p>J'essaie de résoudre le problème du voyageur, autrement dit soit un ensemble de villes, passer par chacune d'entre elles une et une seule fois, le tout en minimisant la distance totale parcourue. Pour l'instant, je fais ça avec un algorithme de <a href="https://en.wikipedia.org/wiki/Simulated_annealing">recuit simulé</a> basique (sans redémarrages etc). </p>
<p>Je stocke les distances dans une matrice de taille N*N avec N le nombre de villes, en considérant que la distance entre A et B est la même qu'entre B et A (j'aurais pu utiliser juste une matrice triangulaire mais bon, c'est pas le plus important là). Pour savoir la distance entre la ville <span>$i$</span> et la ville <span>$j$</span>, je regarde l'élément d'abscisse <span>$i$</span> et d'ordonnée <span>$j$</span> de la matrice. D'ailleurs, cette matrice est stockée au format CSV. La voilà:</p>
<div class="spoiler">
<p><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15</pre></div></td><td class="code"><div class="codehilite"><pre>0,29,82,46,68,52,72,42,51,55,29,74,23,72,46
29,0,55,46,42,43,43,23,23,31,41,51,11,52,21
82,55,0,68,46,55,23,43,41,29,79,21,64,31,51
46,46,68,0,82,15,72,31,62,42,21,51,51,43,64
68,42,46,82,0,74,23,52,21,46,82,58,46,65,23
52,43,55,15,74,0,61,23,55,31,33,37,51,29,59
72,43,23,72,23,61,0,42,23,31,77,37,51,46,33
42,23,43,31,52,23,42,0,33,15,37,33,33,31,37
51,23,41,62,21,55,23,33,0,29,62,46,29,51,11
55,31,29,42,46,31,31,15,29,0,51,21,41,23,37
29,41,79,21,82,33,77,37,62,51,0,65,42,59,61
74,51,21,51,58,37,37,33,46,21,65,0,61,11,55
23,11,64,51,46,51,51,33,29,41,42,61,0,62,23
72,52,31,43,65,29,46,31,51,23,59,11,62,0,59
46,21,51,64,23,59,33,37,11,37,61,55,23,59,0
</pre></div>
</td></tr></table>
</p>
</div>
<h4>Analyse des solutions</h4>
<p>J'ai fait quelques tests en laissant tourner l'algo en boucle pendant la nuit jusqu'à trouver de bonnes solutions. La meilleure que j'ai obtenue était <code>[9, 1, 12, 0, 10, 3, 5, 7, 13, 11, 2, 6, 4, 8, 14]</code>(ce sont les indices des villes, comptés à partir de 0) ce qui donne 294 km. Ca a mis vraiment longtemps avant de trouver cette solution, du coup je me suis demandé quelle était l'efficacité moyenne de cet algo. Pour cela, je fais 100 calculs de solution et je moyenne les distances obtenues. Il en est ressorti que plus la température initiale est élevée (j'avais mis <span>$10^{50}$</span>) ou plus le taux de refroidissement est faible, et meilleures sont les solutions, ce qui n'a rien de surprenant.</p>
<h4>Code</h4>
<div class="spoiler">
<p><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75</pre></div></td><td class="code"><div class="codehilite"><pre><span class="c">#!/usr/bin/python2 -u</span>
<span class="c"># The -u flag is very important, as it prevents output buffering</span>
<span class="kn">import</span> <span class="nn">random</span><span class="o">,</span> <span class="nn">math</span><span class="o">,</span> <span class="nn">csv</span><span class="o">,</span> <span class="nn">sys</span><span class="o">,</span> <span class="nn">copy</span><span class="o">,</span> <span class="nn">time</span>
<span class="k">class</span> <span class="nc">TSP</span><span class="p">:</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">distancematrix</span><span class="p">):</span>
<span class="sd">""" distancematrix is a matrix of size N*N, giving the distance between two cities</span>
<span class="sd"> A matrix allows us to have different distances from A to B than from B to A, but that wouldn't |make sense.</span>
<span class="sd"> Hence we'll use an upper triangular matrix, the rest of the values are undefined and we don't care |about them """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">distances</span> <span class="o">=</span> <span class="n">distancematrix</span>
<span class="bp">self</span><span class="o">.</span><span class="n">size</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">distances</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>
<span class="k">def</span> <span class="nf">stillaccept</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">rdist</span><span class="p">,</span><span class="n">sdist</span><span class="p">,</span><span class="n">t</span><span class="p">):</span>
<span class="k">if</span> <span class="n">random</span><span class="o">.</span><span class="n">random</span><span class="p">()</span> <span class="o"><</span> <span class="n">math</span><span class="o">.</span><span class="n">exp</span><span class="p">((</span><span class="n">rdist</span> <span class="o">-</span> <span class="n">sdist</span><span class="p">)</span><span class="o">/</span><span class="n">t</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">True</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">False</span>
<span class="k">def</span> <span class="nf">simulated_annealing</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">init_temp</span><span class="p">,</span> <span class="n">coolrate</span><span class="p">):</span>
<span class="n">s</span> <span class="o">=</span> <span class="n">Solution</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">size</span><span class="p">)</span> <span class="c"># Initial derpy random solution but that guarantees that all cities are |visited</span>
<span class="n">best</span> <span class="o">=</span> <span class="n">s</span>
<span class="n">bestdistance</span> <span class="o">=</span> <span class="n">best</span><span class="o">.</span><span class="n">totaldistance</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">distances</span><span class="p">)</span>
<span class="n">sdist</span> <span class="o">=</span> <span class="n">bestdistance</span>
<span class="n">t</span> <span class="o">=</span> <span class="n">init_temp</span>
<span class="k">while</span> <span class="n">t</span> <span class="o">></span> <span class="mi">1</span><span class="p">:</span>
<span class="n">r</span> <span class="o">=</span> <span class="n">copy</span><span class="o">.</span><span class="n">deepcopy</span><span class="p">(</span><span class="n">s</span><span class="p">)</span><span class="o">.</span><span class="n">tweak</span><span class="p">()</span>
<span class="n">rdist</span> <span class="o">=</span> <span class="n">r</span><span class="o">.</span><span class="n">totaldistance</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">distances</span><span class="p">)</span>
<span class="k">if</span> <span class="n">rdist</span> <span class="o"><</span> <span class="n">sdist</span> <span class="ow">or</span> <span class="bp">self</span><span class="o">.</span><span class="n">stillaccept</span><span class="p">(</span><span class="n">rdist</span><span class="p">,</span><span class="n">sdist</span><span class="p">,</span><span class="n">t</span><span class="p">):</span>
<span class="n">s</span> <span class="o">=</span> <span class="n">r</span>
<span class="n">sdist</span> <span class="o">=</span> <span class="n">rdist</span>
<span class="n">t</span> <span class="o">*=</span> <span class="mi">1</span><span class="o">-</span><span class="n">coolrate</span> <span class="c"># Cool system</span>
<span class="k">if</span> <span class="n">rdist</span> <span class="o"><</span> <span class="n">bestdistance</span><span class="p">:</span>
<span class="n">best</span> <span class="o">=</span> <span class="n">r</span>
<span class="n">bestdistance</span> <span class="o">=</span> <span class="n">rdist</span>
<span class="k">return</span> <span class="n">best</span><span class="p">,</span> <span class="n">bestdistance</span>
<span class="k">class</span> <span class="nc">Solution</span><span class="p">:</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span><span class="n">size</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">sol</span> <span class="o">=</span> <span class="p">[</span><span class="n">i</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="n">size</span><span class="p">)]</span>
<span class="n">random</span><span class="o">.</span><span class="n">shuffle</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">sol</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">tweak</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">""" Swap two random cities """</span>
<span class="n">i</span><span class="p">,</span><span class="n">j</span> <span class="o">=</span> <span class="n">random</span><span class="o">.</span><span class="n">randrange</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">sol</span><span class="p">)),</span> <span class="n">random</span><span class="o">.</span><span class="n">randrange</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">sol</span><span class="p">))</span>
<span class="n">temp</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">sol</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
<span class="bp">self</span><span class="o">.</span><span class="n">sol</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">sol</span><span class="p">[</span><span class="n">j</span><span class="p">]</span>
<span class="bp">self</span><span class="o">.</span><span class="n">sol</span><span class="p">[</span><span class="n">j</span><span class="p">]</span> <span class="o">=</span> <span class="n">temp</span>
<span class="k">return</span> <span class="bp">self</span>
<span class="k">def</span> <span class="nf">totaldistance</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span><span class="n">distancematrix</span><span class="p">):</span>
<span class="n">distance</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">sol</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">):</span>
<span class="n">distance</span> <span class="o">+=</span> <span class="n">distancematrix</span><span class="p">[</span><span class="bp">self</span><span class="o">.</span><span class="n">sol</span><span class="p">[</span><span class="n">i</span><span class="p">]][</span><span class="bp">self</span><span class="o">.</span><span class="n">sol</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">]]</span>
<span class="k">return</span> <span class="n">distance</span>
<span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">sol</span><span class="o">.</span><span class="n">__repr__</span><span class="p">()</span>
<span class="n">strmat</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">csv</span><span class="o">.</span><span class="n">reader</span><span class="p">(</span><span class="nb">open</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">argv</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="s">"r"</span><span class="p">),</span> <span class="n">delimiter</span><span class="o">=</span><span class="s">','</span><span class="p">))</span>
<span class="n">matrix</span> <span class="o">=</span> <span class="p">[</span> <span class="nb">map</span><span class="p">(</span><span class="nb">float</span><span class="p">,</span> <span class="n">strmat</span><span class="p">[</span><span class="n">i</span><span class="p">])</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">strmat</span><span class="p">))</span> <span class="p">]</span>
<span class="n">tsp</span> <span class="o">=</span> <span class="n">TSP</span><span class="p">(</span><span class="n">matrix</span><span class="p">)</span>
<span class="n">mean</span> <span class="o">=</span> <span class="mf">0.0</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">100</span><span class="p">):</span>
<span class="n">s</span><span class="p">,</span> <span class="n">d</span> <span class="o">=</span> <span class="n">tsp</span><span class="o">.</span><span class="n">simulated_annealing</span><span class="p">(</span><span class="mi">10</span><span class="o">**</span><span class="nb">float</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">argv</span><span class="p">[</span><span class="mi">2</span><span class="p">]),</span> <span class="nb">float</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">argv</span><span class="p">[</span><span class="mi">3</span><span class="p">]))</span>
<span class="n">mean</span> <span class="o">+=</span> <span class="n">d</span> <span class="o">/</span> <span class="mf">100.0</span>
<span class="k">print</span><span class="p">(</span><span class="s">"Average: {}"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">mean</span><span class="p">))</span>
<span class="c">#bestsol, bestdist = tsp.simulated_annealing(10**float(sys.argv[2]), float(sys.argv[3]))</span>
<span class="c">#while True:</span>
<span class="c"># newsol, newdist = tsp.simulated_annealing(float(sys.argv[2]), float(sys.argv[3]))</span>
<span class="c"># if newdist < bestdist:</span>
<span class="c"># bestsol = newsol</span>
<span class="c"># bestdist = newdist</span>
<span class="c"># print("[{}] Best distance so far: {} for {}".format(time.strftime("%H:%M"),bestdist, bestsol))</span>
</pre></div>
</td></tr></table>
</p>
</div>
<p>Pour faire tourner ce code, il faut faire <code>./tsp.py <fichier csv> <exposant de la température> <taux de refroidissement></code> (j'ai mis respectivement 50 et 0.1 pour les tests je crois). Si vous voulez que j'explique plus comment j'ai procédé, dites-le vu que je commente très peu.</p>
<p>Maintenant, je voudrais améliorer encore les performances, autrement qu'en modifiant température et taux de refroidissement, car la valeur moyenne de 433 km est franchement éloignée des 300 km presque optimaux. La page Wikipédia suggère de faire des redémarrages, mais qu'est-ce que je peux faire d'autre pour améliorer l'algo ou le code ?</p>
<p>Merci d'avance</p>Ressources, message #632832015-06-29T10:47:38+02:00KFC/@KFChttps://zestedesavoir.com/forums/sujet/3446/ressources/?page=1#p63283<p>Je peux te donner quelques resources, incluant le livre 'qui coute la peau du cul'.
Contacte moi en PM et on voit ce qu'on peut faire. Par ailleurs, je suis l'un des developpeurs de la plateforme dont fait l'objet le livre 'qui coute la peau du cul', donc si tu veux faire des choses concretes avec ce <em>framework</em>, je peux toujours te filer un coup de main.</p>
<p>Pour le livre cite par unidan, je connais l'auteur et pareil, il a travaille et travaille toujours sur la meme plateforme et tu peux etre sur qu'il s'agit egalement d'un bon bouquin.</p>
<p>Il y a aussi moyen de faire des choses plus theoriques sur le sujet si tu veux t'accrocher un peu, notamment tout ce qui est a la base du recuit simule qui comprends des preuves de convergence base sur des etudes de chaines de Markov, et des preuves de convergence d'algorithmes genetiques simples. Et pour le coup, ce n'est pas dans ces livres que tu trouveras cela (par contre, les resources sont disponibles publiquement dans ce cas).</p>Ressources, message #623442015-06-20T21:22:59+02:00Vayel/@Vayelhttps://zestedesavoir.com/forums/sujet/3446/ressources/?page=1#p62344<p>Höd en parle un peu <a href="https://zestedesavoir.com/tutoriels/beta/987/reflexions-sur-la-complexite-algorithmique-chapitre-2/">ici</a>.</p>
<p>Sinon, je confirme ce que dit Alexandre : un TIPE n'est pas un cours. Le jury accordera beaucoup d'importance à ta démarche personnelle, laquelle sera mise en valeur si tu as l'occasion de choisir un sujet original et personnel.</p>Ressources, message #623352015-06-20T18:52:06+02:00unidan/@unidanhttps://zestedesavoir.com/forums/sujet/3446/ressources/?page=1#p62335<p>Bonjour !</p>
<p>Dans la BU de Lyon j'étais tombé sur celui là, qui est plutôt pas mal de ce que j'en ai lu : <a href="http://www.eyrolles.com/Informatique/Livre/metaheuristiques-pour-l-optimisation-difficile-9782212113686">http://www.eyrolles.com/Informatique/Livre/metaheuristiques-pour-l-optimisation-difficile-9782212113686</a> </p>
<p>Après, n'étant pas grand connaisseur de référence, je te donne seulement un avis sur le sujet : c'est possible de voir plein de métaheuristiques dans un livre, mais bien souvent les livres ne sont pas non plus complet, ils servent d'introduction (déjà bien avancé pourtant). Dans mon cas, c'était surtout les algorithmes génétiques, et à part en allant chercher assez précisément un auteur, les références que je trouvais revenaient toujours à la base (sélection, mutation, crossover et compagnie), et c'est en allant chercher le "A field guide to genetics programming" que j'ai trouvé des choses intéressantes (le livre est disponible en pdf gratuitement d'ailleurs). </p>
<p>Après, pour ce qui est du TIPE, il ne faut pas oublier qu'il faut un sujet derrière, histoire de ne pas arriver le jour J en faisant un cours sur les algorithmes génétiques qui ne parlera probablement pas à tout le monde dans le jury et n'intéressera sûrement pas au moins un des membres du jury. Dans mon cas, c'était la minimisation de circuits logiques (mais je me suis rabattu sur des méthodes plus précises que des métaheuristiques), et un de mes amis a fait son TIPE en utilisant un algorithme de colonie de fourmis sur le repliement des protéines (je laisse le soin à d'autres personnes de me corriger si c'est pas correct, je ne connais strictement rien à tout ça), et un autre l'a fait sur l'utilisation d'algorithme génétique pour faire évoluer les poids d'un réseau de neurones qui contrôle une voiture devant suivre la route. </p>
<p>Une bonne idée, si tu veux vraiment utiliser des métaheuristiques et que tu n'as pas d'idée, ça peut être de choisir celle que tu veux utiliser, et voir des travaux scientifiques qui ont été publiés dessus. </p>
<p>Je fais également de la pub pour <a href="http://zestedesavoir.com/forums/sujet/2343/planification-aerienne/">cet exercice</a> qui était notamment ma première idée de TIPE et qui cherchent des participants, mais il faut garder en tête qu'il est bien plus sûr de pouvoir présenter des résultats et une démarche pour résoudre un problème au jury, que de ressortir de simples aspects théoriques qu'on peut trouver dans des cours.</p>
<p>Edit : il y a également un livre anglais qui développe beaucoup de points, je vais essayer de retrouver ça. </p>Ressources, message #623232015-06-20T18:05:32+02:00anonyme/@anonymehttps://zestedesavoir.com/forums/sujet/3446/ressources/?page=1#p62323<p>Bonjour tout le monde,</p>
<p>Je m'intéresse pas mal aux métaheuristiques, pour ventuellement faire mon TIPE là-dessus. pour l'instant j'ai trouvé les bouquins suivants:</p>
<ul>
<li>|Essentials of Metaheuristics](http://cs.gmu.edu/~sean/book/metaheuristics/), je l'ai téléchargé et ça a l'air pas mal</li>
<li><a href="http://www.amazon.com/Metaheuristics-Design-Implementation-El-Ghazali-Talbi/dp/0470278587/ref%3Dsr_1_3?s=books&ie=UTF8&qid=1434816146&sr=1-3&keywords=metaheuristics">Metaheuristics: From Design to Implementation</a>, c'est la peau du cul qu'on s'arrache à la pince</li>
</ul>
<p>Je vais continuer à chercher, mais en attendant, que pensez-vous de ces deux sources et avez-vous d'autres suggestions ? Pour info, je suis en MPSI.</p>