All modules for which code is available
45 |- Solid.EvolutionaryAlgorithm 46 |
- Solid.GeneticAlgorithm 47 |
- Solid.HarmonySearch 48 |
- Solid.ParticleSwarm 49 |
- Solid.SimulatedAnnealing 50 |
- Solid.StochasticHillClimb 51 |
- Solid.TabuSearch 52 |
3 |
3 | 56 | Please activate JavaScript to enable the search 57 | functionality. 58 |
59 |61 | From here you can search these documents. Enter your search 62 | words into the box below and click "search". Note that the search 63 | function will automatically search for all of the words. Pages 64 | containing fewer words won't appear in the result list. 65 |
66 | 71 | 72 || 57 | s | ||
| 61 | |
62 | Solid | 63 | |
| 66 | |
67 | Solid.EvolutionaryAlgorithm | 68 | |
| 71 | |
72 | Solid.GeneticAlgorithm | 73 | |
| 76 | |
77 | Solid.HarmonySearch | 78 | |
| 81 | |
82 | Solid.ParticleSwarm | 83 | |
| 86 | |
87 | Solid.SimulatedAnnealing | 88 | |
| 91 | |
92 | Solid.StochasticHillClimb | 93 | |
| 96 | |
97 | Solid.TabuSearch | 98 | |
' + _('Hide Search Matches') + '
') 207 | .appendTo($('#searchbox')); 208 | } 209 | }, 210 | 211 | /** 212 | * init the domain index toggle buttons 213 | */ 214 | initIndexTable : function() { 215 | var togglers = $('img.toggler').click(function() { 216 | var src = $(this).attr('src'); 217 | var idnum = $(this).attr('id').substr(7); 218 | $('tr.cg-' + idnum).toggle(); 219 | if (src.substr(-9) == 'minus.png') 220 | $(this).attr('src', src.substr(0, src.length-9) + 'plus.png'); 221 | else 222 | $(this).attr('src', src.substr(0, src.length-8) + 'minus.png'); 223 | }).css('display', ''); 224 | if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) { 225 | togglers.click(); 226 | } 227 | }, 228 | 229 | /** 230 | * helper function to hide the search marks again 231 | */ 232 | hideSearchWords : function() { 233 | $('#searchbox .highlight-link').fadeOut(300); 234 | $('span.highlighted').removeClass('highlighted'); 235 | }, 236 | 237 | /** 238 | * make the url absolute 239 | */ 240 | makeURL : function(relativeURL) { 241 | return DOCUMENTATION_OPTIONS.URL_ROOT + '/' + relativeURL; 242 | }, 243 | 244 | /** 245 | * get the current relative url 246 | */ 247 | getCurrentURL : function() { 248 | var path = document.location.pathname; 249 | var parts = path.split(/\//); 250 | $.each(DOCUMENTATION_OPTIONS.URL_ROOT.split(/\//), function() { 251 | if (this == '..') 252 | parts.pop(); 253 | }); 254 | var url = parts.join('/'); 255 | return path.substring(url.lastIndexOf('/') + 1, path.length - 1); 256 | }, 257 | 258 | initOnKeyListeners: function() { 259 | $(document).keyup(function(event) { 260 | var activeElementType = document.activeElement.tagName; 261 | // don't navigate when in search box or textarea 262 | if (activeElementType !== 'TEXTAREA' && activeElementType !== 'INPUT' && activeElementType !== 'SELECT') { 263 | switch (event.keyCode) { 264 | case 37: // left 265 | var prevHref = $('link[rel="prev"]').prop('href'); 266 | if (prevHref) { 267 | window.location.href = prevHref; 268 | return false; 269 | } 270 | case 39: // right 271 | var nextHref = $('link[rel="next"]').prop('href'); 272 | if (nextHref) { 273 | window.location.href = nextHref; 274 | return false; 275 | } 276 | } 277 | } 278 | }); 279 | } 280 | }; 281 | 282 | // quick alias for translations 283 | _ = Documentation.gettext; 284 | 285 | $(document).ready(function() { 286 | Documentation.init(); 287 | }); -------------------------------------------------------------------------------- /docs/_static/underscore.js: -------------------------------------------------------------------------------- 1 | // Underscore.js 1.3.1 2 | // (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc. 3 | // Underscore is freely distributable under the MIT license. 4 | // Portions of Underscore are inspired or borrowed from Prototype, 5 | // Oliver Steele's Functional, and John Resig's Micro-Templating. 6 | // For all details and documentation: 7 | // http://documentcloud.github.com/underscore 8 | (function(){function q(a,c,d){if(a===c)return a!==0||1/a==1/c;if(a==null||c==null)return a===c;if(a._chain)a=a._wrapped;if(c._chain)c=c._wrapped;if(a.isEqual&&b.isFunction(a.isEqual))return a.isEqual(c);if(c.isEqual&&b.isFunction(c.isEqual))return c.isEqual(a);var e=l.call(a);if(e!=l.call(c))return false;switch(e){case "[object String]":return a==String(c);case "[object Number]":return a!=+a?c!=+c:a==0?1/a==1/c:a==+c;case "[object Date]":case "[object Boolean]":return+a==+c;case "[object RegExp]":return a.source== 9 | c.source&&a.global==c.global&&a.multiline==c.multiline&&a.ignoreCase==c.ignoreCase}if(typeof a!="object"||typeof c!="object")return false;for(var f=d.length;f--;)if(d[f]==a)return true;d.push(a);var f=0,g=true;if(e=="[object Array]"){if(f=a.length,g=f==c.length)for(;f--;)if(!(g=f in a==f in c&&q(a[f],c[f],d)))break}else{if("constructor"in a!="constructor"in c||a.constructor!=c.constructor)return false;for(var h in a)if(b.has(a,h)&&(f++,!(g=b.has(c,h)&&q(a[h],c[h],d))))break;if(g){for(h in c)if(b.has(c, 10 | h)&&!f--)break;g=!f}}d.pop();return g}var r=this,G=r._,n={},k=Array.prototype,o=Object.prototype,i=k.slice,H=k.unshift,l=o.toString,I=o.hasOwnProperty,w=k.forEach,x=k.map,y=k.reduce,z=k.reduceRight,A=k.filter,B=k.every,C=k.some,p=k.indexOf,D=k.lastIndexOf,o=Array.isArray,J=Object.keys,s=Function.prototype.bind,b=function(a){return new m(a)};if(typeof exports!=="undefined"){if(typeof module!=="undefined"&&module.exports)exports=module.exports=b;exports._=b}else r._=b;b.VERSION="1.3.1";var j=b.each= 11 | b.forEach=function(a,c,d){if(a!=null)if(w&&a.forEach===w)a.forEach(c,d);else if(a.length===+a.length)for(var e=0,f=a.length;e
45 | from abc import ABCMeta, abstractmethod
46 | from copy import deepcopy
47 | from math import exp
48 | from random import random
49 |
50 |
51 | [docs]class StochasticHillClimb:
52 | """
53 | Conducts stochastic hill climb
54 | """
55 | __metaclass__ = ABCMeta
56 |
57 | initial_state = None
58 | current_state = None
59 | best_state = None
60 |
61 | cur_steps = 0
62 | max_steps = None
63 |
64 | best_objective = None
65 | max_objective = None
66 |
67 | temp = None
68 |
69 | def __init__(self, initial_state, temp, max_steps, max_objective=None):
70 | """
71 |
72 | :param initial_state: initial state of hill climbing
73 | :param max_steps: maximum steps to run hill climbing for
74 | :param temp: temperature in probabilistic acceptance of transition
75 | :param max_objective: objective function to stop algorithm once reached
76 | """
77 | self.initial_state = initial_state
78 |
79 | if isinstance(max_steps, int) and max_steps > 0:
80 | self.max_steps = max_steps
81 | else:
82 | raise ValueError('Max steps must be a positive integer')
83 |
84 | if max_objective is not None:
85 | if isinstance(max_objective, (float, int)):
86 | self.max_objective = float(max_objective)
87 | else:
88 | raise ValueError('Maximum objective must be a numeric type')
89 |
90 | if isinstance(temp, (float, int)):
91 | self.temp = float(temp)
92 | else:
93 | raise ValueError('Temperature must be a numeric type')
94 |
95 | def __str__(self):
96 | return ('STOCHASTIC HILL CLIMB: \n' +
97 | 'CURRENT STEPS: %d \n' +
98 | 'BEST OBJECTIVE: %f \n' +
99 | 'BEST STATE: %s \n\n') % \
100 | (self.cur_steps, self.best_objective, str(self.best_state))
101 |
102 | def __repr__(self):
103 | return self.__str__()
104 |
105 | def _clear(self):
106 | """
107 | Resets the variables that are altered on a per-run basis of the algorithm
108 |
109 | :return: None
110 | """
111 | self.cur_steps = 0
112 | self.current_state = None
113 | self.best_state = None
114 | self.best_objective = None
115 |
116 | @abstractmethod
117 | def _neighbor(self):
118 | """
119 | Returns a random member of the neighbor of the current state
120 |
121 | :return: a random neighbor, given access to self.current_state
122 | """
123 | pass
124 |
125 | @abstractmethod
126 | def _objective(self, state):
127 | """
128 | Evaluates a given state
129 |
130 | :param state: a state
131 | :return: objective function value of state
132 | """
133 | pass
134 |
135 | def _accept_neighbor(self, neighbor):
136 | """
137 | Probabilistically determines whether or not to accept a transition to a neighbor
138 |
139 | :param neighbor: a state
140 | :return: boolean indicating whether or not transition was accepted
141 | """
142 | try:
143 | p = 1. / (1 + (exp((self._objective(self.current_state) - self._objective(neighbor)) / self.temp)))
144 | except OverflowError:
145 | return True
146 | return True if p >= 1 else p >= random()
147 |
148 | [docs] def run(self, verbose=True):
149 | """
150 | Conducts hill climb
151 |
152 | :param verbose: indicates whether or not to print progress regularly
153 | :return: best state and best objective function value
154 | """
155 | self._clear()
156 | self.current_state = self.initial_state
157 | for i in range(self.max_steps):
158 | self.cur_steps += 1
159 |
160 | if ((i + 1) % 100 == 0) and verbose:
161 | print self
162 |
163 | neighbor = self._neighbor()
164 |
165 | if self._accept_neighbor(neighbor):
166 | self.current_state = neighbor
167 |
168 | if self._objective(self.current_state) > self.best_objective:
169 | self.best_objective = self._objective(self.current_state)
170 | self.best_state = deepcopy(self.current_state)
171 |
172 | if self.max_objective is not None and self.best_objective > self.max_objective:
173 | print "TERMINATING - REACHED MAXIMUM OBJECTIVE"
174 | return self.best_state, self.best_objective
175 | print "TERMINATING - REACHED MAXIMUM STEPS"
176 | return self.best_state, self.best_objective
177 |
45 | from abc import ABCMeta, abstractmethod
46 | from copy import deepcopy
47 | from random import randint, random, shuffle
48 | from collections import deque
49 | from numpy import argmax
50 |
51 | [docs]class TabuSearch:
52 | """
53 | Conducts tabu search
54 | """
55 | __metaclass__ = ABCMeta
56 |
57 | cur_steps = None
58 |
59 | tabu_size = None
60 | tabu_list = None
61 |
62 | initial_state = None
63 | current = None
64 | best = None
65 |
66 | max_steps = None
67 | max_score = None
68 |
69 | def __init__(self, initial_state, tabu_size, max_steps, max_score=None):
70 | """
71 |
72 | :param initial_state: initial state, should implement __eq__ or __cmp__
73 | :param tabu_size: number of states to keep in tabu list
74 | :param max_steps: maximum number of steps to run algorithm for
75 | :param max_score: score to stop algorithm once reached
76 | """
77 | self.initial_state = initial_state
78 |
79 | if isinstance(tabu_size, int) and tabu_size > 0:
80 | self.tabu_size = tabu_size
81 | else:
82 | raise TypeError('Tabu size must be a positive integer')
83 |
84 | if isinstance(max_steps, int) and max_steps > 0:
85 | self.max_steps = max_steps
86 | else:
87 | raise TypeError('Maximum steps must be a positive integer')
88 |
89 | if max_score is not None:
90 | if isinstance(max_score, (int, float)):
91 | self.max_score = float(max_score)
92 | else:
93 | raise TypeError('Maximum score must be a numeric type')
94 |
95 | def __str__(self):
96 | return ('TABU SEARCH: \n' +
97 | 'CURRENT STEPS: %d \n' +
98 | 'BEST SCORE: %f \n' +
99 | 'BEST MEMBER: %s \n\n') % \
100 | (self.cur_steps, self._score(self.best), str(self.best))
101 |
102 | def __repr__(self):
103 | return self.__str__()
104 |
105 | def _clear(self):
106 | """
107 | Resets the variables that are altered on a per-run basis of the algorithm
108 |
109 | :return: None
110 | """
111 | self.cur_steps = 0
112 | self.tabu_list = deque(maxlen=self.tabu_size)
113 | self.current = self.initial_state
114 | self.best = self.initial_state
115 |
116 | @abstractmethod
117 | def _score(self, state):
118 | """
119 | Returns objective function value of a state
120 |
121 | :param state: a state
122 | :return: objective function value of state
123 | """
124 | pass
125 |
126 | @abstractmethod
127 | def _neighborhood(self):
128 | """
129 | Returns list of all members of neighborhood of current state, given self.current
130 |
131 | :return: list of members of neighborhood
132 | """
133 | pass
134 |
135 | def _best(self, neighborhood):
136 | """
137 | Finds the best member of a neighborhood
138 |
139 | :param neighborhood: a neighborhood
140 | :return: best member of neighborhood
141 | """
142 | return neighborhood[argmax([self._score(x) for x in neighborhood])]
143 |
144 | [docs] def run(self, verbose=True):
145 | """
146 | Conducts tabu search
147 |
148 | :param verbose: indicates whether or not to print progress regularly
149 | :return: best state and objective function value of best state
150 | """
151 | self._clear()
152 | for i in range(self.max_steps):
153 | self.cur_steps += 1
154 |
155 | if ((i + 1) % 100 == 0) and verbose:
156 | print self
157 |
158 | neighborhood = self._neighborhood()
159 | neighborhood_best = self._best(neighborhood)
160 |
161 | while True:
162 | if all([x in self.tabu_list for x in neighborhood]):
163 | print "TERMINATING - NO SUITABLE NEIGHBORS"
164 | return self.best, self._score(self.best)
165 | if neighborhood_best in self.tabu_list:
166 | if self._score(neighborhood_best) > self._score(self.best):
167 | self.tabu_list.append(neighborhood_best)
168 | self.best = deepcopy(neighborhood_best)
169 | break
170 | else:
171 | neighborhood.remove(neighborhood_best)
172 | neighborhood_best = self._best(neighborhood)
173 | else:
174 | self.tabu_list.append(neighborhood_best)
175 | self.current = neighborhood_best
176 | if self._score(self.current) > self._score(self.best):
177 | self.best = deepcopy(self.current)
178 | break
179 |
180 | if self.max_score is not None and self._score(self.best) > self.max_score:
181 | print "TERMINATING - REACHED MAXIMUM SCORE"
182 | return self.best, self._score(self.best)
183 | print "TERMINATING - REACHED MAXIMUM STEPS"
184 | return self.best, self._score(self.best)
185 | | 73 | |
|
95 |
|
111 |
|
167 |
|
179 |
|
183 |
|
191 |
|
195 |
|
203 |
|
209 |
|
223 |
|
231 |
|
293 |
|
303 |
|
325 |
|
343 |
|
365 |
|
381 |
|
391 |
|
397 |
|
405 |
|
409 |
|
417 |
45 | from abc import ABCMeta, abstractmethod
46 | from copy import deepcopy
47 | from math import exp
48 | from random import random
49 |
50 |
51 | [docs]class SimulatedAnnealing:
52 | """
53 | Conducts simulated annealing algorithm
54 | """
55 | __metaclass__ = ABCMeta
56 |
57 | initial_state = None
58 | current_state = None
59 | best_state = None
60 |
61 | cur_steps = 0
62 | max_steps = None
63 |
64 | current_energy = None
65 | best_energy = None
66 | min_energy = None
67 |
68 | start_temp = None
69 | current_temp = None
70 | adjust_temp = None
71 |
72 | def _exponential(self, schedule_constant):
73 | def f():
74 | self.current_temp *= schedule_constant
75 | return f
76 |
77 | def _linear(self, schedule_constant):
78 | def f():
79 | self.current_temp -= schedule_constant
80 | return f
81 |
82 | def _get_schedule(self, schedule_str, schedule_constant):
83 | if schedule_str == 'exponential':
84 | return self._exponential(schedule_constant)
85 | elif schedule_str == 'linear':
86 | return self._linear(schedule_constant)
87 | else:
88 | raise ValueError('Annealing schedule must be either "exponential" or "linear"')
89 |
90 | def __init__(self, initial_state, temp_begin, schedule_constant, max_steps,
91 | min_energy=None, schedule='exponential'):
92 | """
93 |
94 | :param initial_state: initial state of annealing algorithm
95 | :param max_steps: maximum number of iterations to conduct annealing for
96 | :param temp_begin: beginning temperature
97 | :param schedule_constant: constant value in annealing schedule function
98 | :param min_energy: energy value to stop algorithm once reached
99 | :param schedule: 'exponential' or 'linear' annealing schedule
100 | """
101 | self.initial_state = initial_state
102 |
103 | if isinstance(max_steps, int) and max_steps > 0:
104 | self.max_steps = max_steps
105 | else:
106 | raise ValueError('Max steps must be a positive integer')
107 |
108 | if min_energy is not None:
109 | if isinstance(min_energy, (float, int)):
110 | self.min_energy = float(min_energy)
111 | else:
112 | raise ValueError('Minimum energy must be a numeric type')
113 |
114 | if isinstance(temp_begin, (float, int)):
115 | self.start_temp = float(temp_begin)
116 | else:
117 | raise ValueError('Starting temperature must be a numeric type')
118 |
119 | self.adjust_temp = self._get_schedule(schedule, schedule_constant)
120 |
121 | def __str__(self):
122 | return ('SIMULATED ANNEALING: \n' +
123 | 'CURRENT STEPS: %d \n' +
124 | 'CURRENT TEMPERATURE: %f \n' +
125 | 'BEST ENERGY: %f \n' +
126 | 'BEST STATE: %s \n\n') % \
127 | (self.cur_steps, self.current_temp, self.best_energy, str(self.best_state))
128 |
129 | def __repr__(self):
130 | return self.__str__()
131 |
132 | def _clear(self):
133 | """
134 | Resets the variables that are altered on a per-run basis of the algorithm
135 |
136 | :return: None
137 | """
138 | self.cur_steps = 0
139 | self.current_state = None
140 | self.best_state = None
141 | self.current_energy = None
142 | self.best_energy = None
143 |
144 | @abstractmethod
145 | def _neighbor(self):
146 | """
147 | Returns a random member of the neighbor of the current state
148 |
149 | :return: a random neighbor, given access to self.current_state
150 | """
151 | pass
152 |
153 | @abstractmethod
154 | def _energy(self, state):
155 | """
156 | Finds the energy of a given state
157 |
158 | :param state: a state
159 | :return: energy of state
160 | """
161 | pass
162 |
163 | def _accept_neighbor(self, neighbor):
164 | """
165 | Probabilistically determines whether or not to accept a transition to a neighbor
166 |
167 | :param neighbor: a state
168 | :return: boolean indicating whether or not transition is accepted
169 | """
170 | try:
171 | p = exp(-(self._energy(neighbor) - self._energy(self.current_state)) / self.current_temp)
172 | except OverflowError:
173 | return True
174 | return True if p >= 1 else p >= random()
175 |
176 | [docs] def run(self, verbose=True):
177 | """
178 | Conducts simulated annealing
179 |
180 | :param verbose: indicates whether or not to print progress regularly
181 | :return: best state and best energy
182 | """
183 | self._clear()
184 | self.current_state = self.initial_state
185 | self.current_temp = self.start_temp
186 | self.best_energy = self._energy(self.current_state)
187 | for i in range(self.max_steps):
188 | self.cur_steps += 1
189 |
190 | if ((i + 1) % 100 == 0) and verbose:
191 | print self
192 |
193 | neighbor = self._neighbor()
194 |
195 | if self._accept_neighbor(neighbor):
196 | self.current_state = neighbor
197 | self.current_energy = self._energy(self.current_state)
198 |
199 | if self.current_energy < self.best_energy:
200 | self.best_energy = self.current_energy
201 | self.best_state = deepcopy(self.current_state)
202 |
203 | if self.min_energy is not None and self.current_energy < self.min_energy:
204 | print "TERMINATING - REACHED MINIMUM ENERGY"
205 | return self.best_state, self.best_energy
206 |
207 | self.adjust_temp()
208 | if self.current_temp < 0.000001:
209 | print "TERMINATING - REACHED TEMPERATURE OF 0"
210 | return self.best_state, self.best_energy
211 | print "TERMINATING - REACHED MAXIMUM STEPS"
212 | return self.best_state, self.best_energy
213 |