diff --git a/notebooks/5_local_search/1.png b/notebooks/5_local_search/1.png
new file mode 100644
index 00000000..4d0f5bd5
Binary files /dev/null and b/notebooks/5_local_search/1.png differ
diff --git a/notebooks/5_local_search/2.png b/notebooks/5_local_search/2.png
new file mode 100644
index 00000000..5e74bd6c
Binary files /dev/null and b/notebooks/5_local_search/2.png differ
diff --git a/notebooks/5_local_search/3.png b/notebooks/5_local_search/3.png
new file mode 100644
index 00000000..a16f4e3e
Binary files /dev/null and b/notebooks/5_local_search/3.png differ
diff --git a/notebooks/5_local_search/8-queene-problem.png b/notebooks/5_local_search/8-queene-problem.png
new file mode 100644
index 00000000..f848365d
Binary files /dev/null and b/notebooks/5_local_search/8-queene-problem.png differ
diff --git a/notebooks/5_local_search/8Queens_Genetics.jpg b/notebooks/5_local_search/8Queens_Genetics.jpg
new file mode 100644
index 00000000..dff5748b
Binary files /dev/null and b/notebooks/5_local_search/8Queens_Genetics.jpg differ
diff --git a/notebooks/5_local_search/Genetic_psudocode.jpg b/notebooks/5_local_search/Genetic_psudocode.jpg
new file mode 100644
index 00000000..ffc02f1e
Binary files /dev/null and b/notebooks/5_local_search/Genetic_psudocode.jpg differ
diff --git a/notebooks/5_local_search/LNS2.png b/notebooks/5_local_search/LNS2.png
new file mode 100644
index 00000000..d0c20bdc
Binary files /dev/null and b/notebooks/5_local_search/LNS2.png differ
diff --git a/notebooks/5_local_search/LNS_ex.jpg b/notebooks/5_local_search/LNS_ex.jpg
new file mode 100644
index 00000000..84b63a34
Binary files /dev/null and b/notebooks/5_local_search/LNS_ex.jpg differ
diff --git a/notebooks/5_local_search/README.md b/notebooks/5_local_search/README.md
deleted file mode 100644
index c40215c9..00000000
--- a/notebooks/5_local_search/README.md
+++ /dev/null
@@ -1,5 +0,0 @@
-# Local Search
-
-- Mahsa Amani
-- Mobina Poornemant
-- Arman Zarei
diff --git a/notebooks/5_local_search/Simulated_Annealing_psudocode.jpg b/notebooks/5_local_search/Simulated_Annealing_psudocode.jpg
new file mode 100644
index 00000000..3ad57a7d
Binary files /dev/null and b/notebooks/5_local_search/Simulated_Annealing_psudocode.jpg differ
diff --git a/notebooks/5_local_search/hc.png b/notebooks/5_local_search/hc.png
new file mode 100644
index 00000000..7a6938ed
Binary files /dev/null and b/notebooks/5_local_search/hc.png differ
diff --git a/notebooks/5_local_search/hill-climbing.png b/notebooks/5_local_search/hill-climbing.png
new file mode 100644
index 00000000..32ca3b9a
Binary files /dev/null and b/notebooks/5_local_search/hill-climbing.png differ
diff --git a/notebooks/5_local_search/index.ipynb b/notebooks/5_local_search/index.ipynb
deleted file mode 100644
index 520b3eaf..00000000
--- a/notebooks/5_local_search/index.ipynb
+++ /dev/null
@@ -1 +0,0 @@
-{"nbformat":4,"nbformat_minor":0,"metadata":{"kernelspec":{"display_name":"Python 3.8.1 64-bit","language":"python","name":"python38164bitdac97052df6b4ee89acbe124d3b23037"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.8.1"},"colab":{"name":"AI_project.ipynb","provenance":[],"collapsed_sections":[]}},"cells":[{"cell_type":"markdown","metadata":{"id":"MQGEDm7VyXRs"},"source":["# Local Search"]},{"cell_type":"markdown","metadata":{"id":"TYrJbpD7-uI9"},"source":["local search is a heuristic method for solving computationally hard optimization problems. Local search can be used on problems that can be formulated as finding a solution maximizing a criterion among a number of candidate solutions. Local search algorithms move from solution to solution in the space of candidate solutions (the search space) by applying local changes, until a solution deemed optimal is found or a time bound is elapsed."]},{"cell_type":"markdown","metadata":{"id":"rysdjagC_Pxg"},"source":["As you can see, in local search, the path to the goal is not important to us and we're only trying to find the state of the goal. In many problems our purpose is to find that goal state rather than the path that takes us there. "]},{"cell_type":"markdown","metadata":{"id":"4wFRqgEmAQrr"},"source":["#### 1. Path to goal is important\n","\n","- 8-Puzzle\n","- Chess\n","- Theorem proving\n","- Route finding"]},{"cell_type":"markdown","metadata":{"id":"z5kv_-44C1ME"},"source":["##### 1.1. Goal state itself is important\n","\n","- 8 Queens\n","- TSP\n","- Job-Shop Scheduling\n","- Automatic program generation\n","- VLSI Layout"]},{"cell_type":"markdown","metadata":{"id":"AiLqmzapD5Ns"},"source":["### 2. Partial state formulation vs. Complete state formulation"]},{"cell_type":"markdown","metadata":{"id":"Ekz71MvDEALY"},"source":["In partial state formulation, each path represent a solution to the problem (as we have seen the systematic exploration of search graph) but in complete state formulation each state represent a solution to the problem."]},{"cell_type":"markdown","metadata":{"id":"zcXO5q9hEgXy"},"source":["#### 2.1. Time and memory complexity \n","As you have seen previously, In Systematic exploration of search space, the memory was exponential. But here it's reduced to O(1) instead and the computational time complexity reduced from exponential to O(T) where we choose such T to limit the number of iterations."]},{"cell_type":"markdown","metadata":{"id":"DFtHu8WvIhtY"},"source":["## 3. Constraint Satisfaction vs. Constraint Optimization"]},{"cell_type":"markdown","metadata":{"id":"T7p_SQQsIpEF"},"source":["In constraint satisfaction problems, we look for states that satisfy some constraints (e.g. in-queens problem, where the constraints are: no two queens can attack each other). In the other hand, in constraint optimization, beside satisfying some constraints, we are looking for optimizing an objective function (whether minimizing or maximizing) (e.g. TSP where the objective function is to minimize the total weight of the edges)"]},{"cell_type":"markdown","metadata":{"id":"m5Ds2YEzJ0R3"},"source":["We can convert a constraint satisfaction problem to a constraint optimization problem. for example consider the n-queens problem. we can set our objective function \n","> h = # pairs of queens that attack each other\n","\n","or\n","\n","> h = # constraints that are violated\n","\n","and then we can solve the optimization version of the problem."]},{"cell_type":"markdown","metadata":{"id":"y6z_J1VLLqVw"},"source":["We also can convert a constraint optimization problem to **some** constraint satisfaction problems (Can do something like a binary search or we can do it in linear time. e.g. for minimizing function *f* we set a constraint *f=a* (for some reasonable a) and at each step we solve the constraint satisfaction version of the problem and decrease *a* by one)"]},{"cell_type":"markdown","metadata":{"id":"_CBxdaYDNLo8"},"source":["## 4. Trivial Algorithms"]},{"cell_type":"markdown","metadata":{"id":"fGsx6b0iNPZV"},"source":["* ### Random Sampling\n","Generate a state randomly at each step and keep the optimal one and update it at each iteration"]},{"cell_type":"markdown","metadata":{"id":"RhiBaUpDNiUL"},"source":["* ### Random Walk\n","Randonmly pick a **neighbor** of the current state"]},{"cell_type":"markdown","metadata":{"id":"8-G8UDGVPI25"},"source":["Both algorithms are asymptotically complete (If the state space is finite, each state is visited at a fixed rate asymptotically)"]},{"cell_type":"markdown","metadata":{"id":"NjlIY7GSF8DI"},"source":["## 5. Hill Climbing"]},{"cell_type":"markdown","metadata":{"id":"3-rMWzUqLJF2"},"source":["a better solution is to use a local search algorithm that continuously moves in the direction of increasing elevation/value to find the peak of the mountain or the best solution to the problem. **Hill-climbing algorithm** terminates when it reaches a peak value where no neighbor has a higher value.\n","Note that, in this algorithm nodes only contain the state and the value of the objective function in that state (not path) so may see previous states. \n","It is also called **greedy local search** as it only looks to its good immediate neighbor state and not beyond that. This may seem like a good thing, but it's not: hill climbing can get stuck in a local optimum easily so its convergence depends on the **initial state**.\n"]},{"cell_type":"markdown","metadata":{"id":"2v42PwhCU7bI"},"source":[""]},{"cell_type":"markdown","metadata":{"id":"3nVVXDhFVATk"},"source":["### 5.1. Example: 8-queens problem:\n","States: 8 queens on the board, one per column (88 ≈ 17 𝑚𝑖𝑙𝑙𝑖𝑜𝑛) \n","Successors(s): all states resulted from 𝑠 by moving a single queen to another square of the same column (8 × 7 = 56) \n","Cost function ℎ(s): number of queen pairs that are attacking each other, directly or indirectly. \n","Global minimum: ℎ(s) = 0 \n"]},{"cell_type":"markdown","metadata":{"id":"1JJlgV2HVdzn"},"source":[""]},{"cell_type":"markdown","metadata":{"id":"vlbmRuQxVq4b"},"source":["in the above example, the hill-climbing algorithm converges to h = 1 and it can't do any action to improve h, so it stuck at the local minimum. \n","### 5.2. 8-queens statistics:\n","*\tState-space of size ≈17 million \n","*\tStarting from a random state, steepest-ascent hill-climbing solves **14%** of the problem instances and 86% of the time getting stuck. \n","*\tIt takes **4 steps** on average when it succeeds, 3 when it gets stuck. \n"]},{"cell_type":"markdown","metadata":{"id":"a48zgD-nWEhx"},"source":["### 5.3. Hill-climbing properties: \n","\n","*\t**Not complete**: because doesn't have memory and may see **repetitive states** and also has issues with **local optimal**. \n","* In the worst case has a terrible running time. \n","*\tThe space complexity of O(1). \n","*\tSimple and often very fast. \n","\n","So the solutions to improve the Hill-climbing algorithm take into account **recurring states** and **local optimal**. \n"]},{"cell_type":"markdown","metadata":{"id":"yujfGOjCWiPH"},"source":["For **convex** or **concave** functions, like the examples below, the hill-climbing algorithm gets the optimal solution, because the local optimal is the **same** as global optimal. \n",""]},{"cell_type":"markdown","metadata":{"id":"KxbalXziXbUk"},"source":["### 5.4. Hill-climbing search problems:\n","*\t**Local optimal** (except convex/concave functions that mentioned before)\n","*\t**Plateau**: a flat area (flat local optima, shoulder) \n"," \n","\n"," \n"," \n"," \n","\n"]},{"cell_type":"markdown","metadata":{"id":"3VXU8UOMZ-rh"},"source":["* **Diagonal ridges**: From each local maximum all the available actions point downhill, but there is an uphill path! \n","\n"," \n",""]},{"cell_type":"markdown","metadata":{"id":"kGOGmNmjaYUg"},"source":["### 5.5. Sideway moves\n","In some problems, like n-queens, converging to local optimal isn't acceptable and should find some better solutions. \n","A solution that may help is to use **sideway moves**: If no downhill (uphill) moves, allow sideways moves in hope that the algorithm can escape shoulders. There might be a limit to the number of sideway moves allowed to avoid infinite loops. \n","For the 8-queens problem, if set 100 for the sideway moves limit, the percentage of problems solved raises from 14 to **94%**, and 21 steps are needed for every successful solution, 64 for each failure. So using sideway moves the probability of convergence to optimal solution increases but the converge time increases too. \n","When **sideway moves** are allowed, performance improves ...\n"]},{"cell_type":"markdown","metadata":{"id":"q_llp1uUa2qK"},"source":["### 5.6. Stochastic Variations\n","Another solution that helps hill-climbing to be complete, is **Stochastic Variations**. When the state-space landscape has local optima, any search that moves only in the greedy direction cannot be complete. \n","the idea of stochastic variations is to combine **random-walk** and **greedy hill-climbing**. \n","At each step do one of the following: \n","*\t**Greedy**: With probability, p moves to the neighbor with the largest value.\n","*\t**Random**: With probability, 1-p moves to a random neighbor.\n"]},{"cell_type":"markdown","metadata":{"id":"BNE0DnHFbQsm"},"source":["### 5.7. Random-restart Hill-climbing\n","All previous versions are **incomplete** because of getting stuck on local optima, but the **random-restart hill-climbing** gives a complete algorithm. \n","In random-restart hill-climbing, start with the **initial random state**, and if terminates with the failure, choose another initial random state, and so on... \n"," If **p** be the probability of success in each hill-climbing search, then the **expected number of restarts will be 1/p**. \n","When multiple restarts are allowed, performance improves...\n"]},{"cell_type":"markdown","metadata":{"id":"0-QbYjdabslA"},"source":["### 5.8. Hill-Climbing with both Random Walk & Random Sampling\n","If we want to increase the randomness we can combine ideas of **greedy local search**, **random walk**, and **random restart**.\n","At each step do one of the three with the same probability:\n","*\t**Greedy**: move to the neighbor with the largest value\n","*\t**Random Walk**: move to a random neighbor\n","*\t**Random Restart**: Start over from a new, random state\n","\n"]},{"cell_type":"markdown","metadata":{"id":"BY3kkElJb-DZ"},"source":["### 5.9. Tabu search:\n","**Tabu Search** works like hill-Climbing, but it maintains a **tabu list** of constant size, like k, to avoid getting stuck in local optima. The tabu list holds k recent used objects that are taboo to use for now. Moves that involve an object in the tabu list, are not accepted.\n","Tabu search raises the space complexity from O(1) to O(k) but in many problems that use sideway moves, it improves the performance of hill-climbing.\n"]},{"cell_type":"markdown","metadata":{"id":"6sz3ve2cyXSi"},"source":["## 6. Simulated annealing"]},{"cell_type":"markdown","metadata":{"id":"01FRBl3ayXSm"},"source":["__Simulating annealing (SA)__ is one the search algorithms.The idea which is used for SA is close to random walking in other search algorithms. SA uses physical concepts for escaping local optimas by allowing some bad moves and gradually decreasing their size and frequency because if these bad moves go on and the answer be somewhere near global optima, it will get far from global optima.This method proposed in 1983 by IBM researchers for solving VLSI layout problems."]},{"cell_type":"markdown","metadata":{"id":"1TRskALeyXSp"},"source":["Let's have a look at a physical analogy:\n","- Imagine letting a ball roll downhill on the function surface\n","- Now shake the surface, while the ball rolls\n","- Gradually reduce the amount of shaking"]},{"cell_type":"markdown","metadata":{"id":"c_c1aLqHyXSr"},"source":["The picture below demonstraits the places where ball probably will be and the next state is getting closer to goal state which is global optima:\n",""]},{"cell_type":"markdown","metadata":{"id":"_U52mJKmyXSt"},"source":["Simulated annealing refers to the process of cooling a liquid until it form crystalline shape. This physiacal process must be done slowly to form better crystalline shapes.At first molecules of liquid have too much kinetic energy and are moving so fast with brownian motions, by cooling it slowly seems that the energy is getting less and less. In this process due to the fact that we are reducing the temperature gradually, number of bad moves or moves with too much energy will decrease until it converges to global optima."]},{"cell_type":"markdown","metadata":{"id":"yIv8xVsWyXSw"},"source":["Based on this intuition:\n","- Define a variable named T for the temperature.\n","- The value of T is high at first.\n","- According to temperature schedule, reduce this value.\n"," - In high temperature probability of \"locally bad\" moves is higher.\n"," - In low temperature probability of \"locally bad\" moves is lower."]},{"cell_type":"markdown","metadata":{"id":"SadVzy29yXSy"},"source":["### 6.1. Pseudocode"]},{"cell_type":"markdown","metadata":{"id":"2-eWnSM4yXSz"},"source":["The following pseudocode presents the simulated annealing heuristic as described above:"]},{"cell_type":"markdown","metadata":{"id":"lmApoYIryXS1"},"source":[""]},{"cell_type":"markdown","metadata":{"id":"zFq3pNm5yXS3"},"source":["### 6.2. Effect of temperature"]},{"cell_type":"markdown","metadata":{"id":"jrTdqq_eyXS6"},"source":["This picture illustrates 2 points:\n","- At first, the high temprature causes more bad moves and the acceptation probability drops slowly(low slope).\n","- As the temperature decreases, the bad moves' probability converges to zero so fast(high slope)."]},{"cell_type":"markdown","metadata":{"id":"7ErvIyi9yXS7"},"source":["\n"]},{"cell_type":"markdown","metadata":{"id":"Uoh4c_-pyXS8"},"source":["In this exmaple, SA is searching for a maximum. By cooling the temperature slowly, the global maximum is found. "]},{"cell_type":"markdown","metadata":{"id":"dzrxlYXNyXS-"},"source":[""]},{"cell_type":"markdown","metadata":{"id":"vyuR-PhAyXS_"},"source":["### 6.3. Simulated Annealing in practice"]},{"cell_type":"markdown","metadata":{"id":"iFT5AY68yXTC"},"source":["__How to define this schedulability?__\n","
\n","There is only one theorem about this.\n","
\n","_Theorem_: If T is decreased sufficiently slow, global optima will be found approximately with probability of 1.\n","
\n","__Is this rate same for all problems?__\n","
\n","No, it depends on the problem.\n","
\n","__Now, Is this theorem a useful guarantee?__\n","
\n","Convergence can be guaranteed if at each step, T drops no more quickly than $\\frac{C}{log n}$, where C is a constant and problem dependent and n is the number of steps so far.In practice different Cs are used to find the best choice for problem."]},{"cell_type":"markdown","metadata":{"id":"8h3Uy0C8yXTF"},"source":["### 6.4. Other applications"]},{"cell_type":"markdown","metadata":{"id":"sFC7Qy5vyXTH"},"source":["- [Traveling salesman](https://en.wikipedia.org/wiki/Travelling_salesman_problem)\n","- [Graph partitioning](https://en.wikipedia.org/wiki/Graph_partition)\n","- [Graph coloring](https://en.wikipedia.org/wiki/Graph_coloring)\n","- [Scheduling](https://en.wikipedia.org/wiki/Scheduling_(computing))\n","- [Facility layout](https://www.managementstudyguide.com/facility-layout.htm)\n","- [Image processing](https://en.wikipedia.org/wiki/Digital_image_processing)\n","- ..."]},{"cell_type":"markdown","metadata":{"id":"pKk-vJqZyXTL"},"source":["## 7. Local beam search"]},{"cell_type":"markdown","metadata":{"id":"eg3tHaSA4IG3"},"source":["Keeping only one node in memory is an extreme reaction to memory problems.\n","
\n","__Local beam search__ is another algorithm which keeps track of k states instead of keeping only one node in memory."]},{"cell_type":"markdown","metadata":{"id":"-eg2kNln88KD"},"source":["**Now, How?**\n","
\n","- Initially: Select k states randomly. \n","- Next: Determine all successors of k states.\n","- If any successor is goal, search has finished.\n","- Else select k best from successors and repeat."]},{"cell_type":"markdown","metadata":{"id":"BtK27rSv-6_d"},"source":["This is an example of **Local Beam Search** when k = 3:"]},{"cell_type":"markdown","metadata":{"id":"r39NLpIb59Zw"},"source":["\n"]},{"cell_type":"markdown","metadata":{"id":"5gjLKGoYFCzp"},"source":["$\\star$ Note that this algorithm is not the same as k random-start searches run in parallel. In Beam search, searches that find good states recruit other searches to join them.\n"]},{"cell_type":"markdown","metadata":{"id":"V9F_sDsgMtGI"},"source":["### 7.1. Stochastic Beam Search"]},{"cell_type":"markdown","metadata":{"id":"NxVbZIVbMvtu"},"source":["Quite often, all k states end up on same local hill.\n","
\n","__So, What should be done?__\n","
\n","The idea is to use **Stochastic beam search** which chooses k successors randomly,biased towards good ones."]},{"cell_type":"markdown","metadata":{"id":"ITypdfm7AQCd"},"source":["### 7.2. Uses"]},{"cell_type":"markdown","metadata":{"id":"N58yi-AvAWLU"},"source":["This algorithm has many uses in:\n","- MT ([Machine Translation](https://en.wikipedia.org/wiki/Machine_translation))\n","- NLP ([Natural Language Processing](https://en.wikipedia.org/wiki/Natural_language_processing))"]},{"cell_type":"markdown","metadata":{"id":"qsar3LpvjjlT"},"source":["## 8. Genetic Algorithms"]},{"cell_type":"markdown","metadata":{"id":"f2RXmJtmjm-3"},"source":["- ### A variant of stochastic beam search\n","Successors can be generated by combining two parent states rather than modifying a single state\n"]},{"cell_type":"markdown","metadata":{"id":"Xy3_XnsZj67K"},"source":["### 8.1. Algorithm"]},{"cell_type":"markdown","metadata":{"id":"cFUrtth1kFkb"},"source":["- A State (solution) is represented as a string over a finite alphabet (e.g. a chromosome containing genes)\n","\n","- Start with *k* randomly generated states (**Population**)\n","\n","- Evaluation function to evaluate states (Higher values for better states) (**Fitness function**)\n","\n","- Combining two parent states and getting offsprings (**Cross-over**)\n"," - Cross-over point can be selected randomly\n","\n","- Reproduced states can be slightly modified with a probability of *P* (**mutation**)\n","\n","- The next generation of states is produces by selection (based on fitness function), crossover and mutation \n"]},{"cell_type":"markdown","metadata":{"id":"Gw4E2VAVlghB"},"source":["Keeping all these in mind, we will go into more detail in the below example"]},{"cell_type":"markdown","metadata":{"id":"Ez9hAQqyln4_"},"source":["### 8.2. Example: 8-Queens\n"]},{"cell_type":"markdown","metadata":{"id":"9ZRp1X8Ilq-Z"},"source":["- Describe the state as a string\n","\n"," "]},{"cell_type":"markdown","metadata":{"id":"-AE68ZMGmSQS"},"source":["- **Fitness function** : number of non-attacking pairs of queens (24 for above figure)"]},{"cell_type":"markdown","metadata":{"id":"vtpXLBZxmeop"},"source":["- **Cross-over** : To select some part of the state from one parent and the rest from another\n","\n"," "]},{"cell_type":"markdown","metadata":{"id":"jMLjQKI0m9hT"},"source":["- **Mutation** : To change a small part of one state with a small probability \n","\n"," "]},{"cell_type":"markdown","metadata":{"id":"gmv2GHeBnkiU"},"source":["- **Selection** : We can also have a selection step that selects from the population and the probability of the selection of each individual in population is with respect to it's fitness value (See example below)"]},{"cell_type":"markdown","metadata":{"id":"5qSmgLTSoFyk"},"source":["### 8.3. Another variant of genetic algorithm for 8-Queens"]},{"cell_type":"markdown","metadata":{"id":"x2xfQjxBoqqu"},"source":[""]},{"cell_type":"markdown","metadata":{"id":"Se5LpXkGoswV"},"source":["And in the picture below you can see the way we calculated the fitness function"]},{"cell_type":"markdown","metadata":{"id":"c8d4FFOboMpo"},"source":[""]},{"cell_type":"markdown","metadata":{"id":"N52Mb_yQoi2O"},"source":["### 8.4. Pros. and Cons."]},{"cell_type":"markdown","metadata":{"id":"q0QnVxXKpIpE"},"source":["- **Positive points**\n"," - Random exploration can find solutions that local search can't (via crossover primarily)\n","\n"," - Appealing connection to human evaluation (\"neural\" networks, and \"genetic\" algorithms are metaphors!)\n","\n","- **Negative points**\n"," - Large number of \"tunable\" parameters\n"," - Lack of good empirical studies comparing to simpler methods\n"," - Useful on some (small?) set of problems but no convincing evidence that GAs are better than hill-climbing with random restarts in general"]},{"cell_type":"markdown","metadata":{"id":"sEackcKB82NI"},"source":["## 9. Summary"]},{"cell_type":"markdown","metadata":{"id":"9eMLSNE8858v"},"source":["All the introduced methods are related to the search problems which are computationally hard. These algorithms move from solution to solution in the space of candidate solutions (the search space) by applying local changes, until a solution deemed optimal is found or a time bound is elapsed.\n","\n","As mentioned before, in the exploration of search space, the space complexity was exponential; But using these local algorithms, it is reduced to O(1) instead, and the computational time complexity, which was exponential, is reduced to O(T) where T is the number of iterations.\n","\n","\n"]},{"cell_type":"markdown","metadata":{"id":"D4TZ11yp7YyK"},"source":["## 10. References"]},{"cell_type":"markdown","metadata":{"id":"Wjid5Lxb7h9y"},"source":["\n","\n","* [AI course at Sharif University of Technology](http://ce.sharif.edu/courses/99-00/1/ce417-2/index.php/section/resources/file/resources)\n","* https://en.wikipedia.org/wiki/Simulated_annealing\n"]},{"cell_type":"code","metadata":{"id":"0QkTU_BU7pqA"},"source":[""],"execution_count":null,"outputs":[]}]}
\ No newline at end of file
diff --git a/notebooks/5_local_search/index.md b/notebooks/5_local_search/index.md
new file mode 100644
index 00000000..7f876c17
--- /dev/null
+++ b/notebooks/5_local_search/index.md
@@ -0,0 +1,509 @@
+# Local Search
+
+## Contents
+
+- [Introduction](#introduction)
+ - [What is Local Search?](#WhatIsLocalSearch)
+ - [Advantages](#Advantages)
+- [Methods](#methods)
+ - [Hill Climbing](#hillClimbing)
+ - [Tabu Search](#tabuSearch)
+ - [Local Beam Search](#localBeamSearch)
+ - [Simulated Annealing](#SimulatedAnnealing)
+ - [Genetic Algorithms](#geneticAlgorithms)
+ - [Large Neighborhood Search](#largeN)
+- [Summary](#summary)
+- [References](#references)
+
+## 1. Introduction
+
+### 1.1. What is Local Search?
+
+Local Search is a heuristic method for solving computationally hard constraint satisfaction or optimization problems. The family of local search methods is typically used in search problems where the search space is either very huge or infinite. In such Problems, classical search algorithms do not work efficiently.
+
+Usually, local search is used for problems that have a state as its solution, and for many problems the path to the final solution is irrelevant. The procedure of this method is quite simple, at first the algorithm starts from a solution that may not be optimal, or may not satisfy all the constraints, and by every step or iteration, the algorithm tries to find a slightly better solution. This gradual improvement of the solution is done by examining different neighbors of the current state and choosing the best neighbor as the next state of the search.
+
+An example of the application of local search is solving the [travelling salesman problem](https://en.wikipedia.org/wiki/Travelling_salesman_problem). In each step, we may try to replace two edges with two other edges which may result in a shorter cycle in the graph.
+
+
+ 
+
+
+
+### 1.2. Advantages
+
+Local search has a memory complexity of O(1) which is very efficient. This is the case because only the current state of the program is saved in memory. The time complexity of local search is O(T) which T is the number of iterations.
+
+
+## 2. Methods
+
+### 2.1. Hill Climbing
+Imagine you want to climb a mountain and you need to find a path that leads to the peak. And ofcourse you want to do this as fast as possible. What would you do if you were in this situation?
+The first inituitive idea that comes to mind is roughly simple, in each step try to go as high as possible, done. This is what '*Hill Climbing*' algorithm do. This iterative algorithm starts with a random state and in each iteartion tries to do the best, which means chossing a neighbor that has the highset value among all other neighbors. This algorithm continues till we reach a local maximum.
+
+```
+function Hill-Climbing(problem) returns a state
+ current <- make_node(problem.initial-state)
+ while (True):
+ neighbor <- highest-valued successor of current
+ if neighbor.value <= current.value:
+ return current
+ current <- neighbor
+```
+
+ 
+
+
+###### Example 2.1.1 (8-queens Problem)
+This is one of the problmes which can be formulated as a *'local search'* problem. Our goal is to place 8 queen on a chess board in a way that no queen attacks the others. Each state is a placing of queens on board and the value of each state is 'the number of attacking queens'. This problem is a minimization version of local search and our goal is to find a state that has the least cost(value). The successor of each state comes from moving just one queen in her column.
+
+Using *'hill climbing'* to solve this problem leads to following results:
+
+- (Probability of sucesse for a random initial state) p = 0.14
+- Average number of moves to terminate per trial:
+ - 4 when succeeding
+ - 3 when getting stuck
+- Expected total number of moves for an instance:
+ - 
moves needs
+
+
+
+#### 2.1.1 Hill Climbing Pros and Cons
+This greedy algorithm is simple enough to implement, it just consists of a loop and a search to find best neighbor. Also it doesn't require any special data structure cause in each state we just need current state and its neighbores. But this simplisity comes with costs. Unfortunately *'hill climbing'* will not work well in the following situations:
+
+- **Local Maxima**: First of all, by using this algorithm we might stuck in local maxima! A local maxima is an state which has higher value than all of its neighbors. If algorithm starts from near this states, it will stuck in this points and will not find global maxima. so this version of 'hill climbing' is *incomplete*.(Below Figure)
+- **Ridges**: Ridges are situations that there exist some local maxima but they are not connected directly to each other and its hard for algorithm to choise where to go when reachs this points. (Below Figure)
+- **Plateaus**: This is a situation that there exist a flat area or flat maxima in space. In case of flat maxima again we stuck in local maxima, and in case of flat area (shoulders) algorithm will terminate cause current value is equal to or greather than all other its neighbors, but it hasn't find any maximal point.
+
+
+
+To solve above problme of *'hill climbing'*, different versions of this algorithm have been developed. In the next section we are going to briefly talk about this versions.
+#### 2.1.2 Versions of Hill Climbing
+##### 2.1.2.1 Using Sideway Moves
+This version has been invented to solve *'Plateaus'* problem. The only different is that in this version, algorithm is allowed to move along plateaus in hope to get out of shuolders. But if we use sideway moves without any consideration, it might get stuck in a flat maxima cause it will go back and forth between this region states. To solve this problem we add a limitation on the number of consecutive sideway moves to prevent algorithm from getting stuck in infinite loops.
+
+###### Example 2.1.2 (8-queens)
+If we run 'hill climbing with sideway moves' on 8-queens problem, the results get much better but it comes with a cost. The number of moves for algorithm increase.
+
+- (Probability of success) p = 0.94
+- Average number of moves to terminate per trial:
+ - 21 when succeeding
+ - 65 when getting stuck
+- Expected total number of moves for an instance:
+ - 
moves needs
+
+##### 2.1.2.2 Stochastic hill climbing
+This version has been developed to solve *'incompletness*' of hill climbing, but does not completely solve this problem. It only helps to have chance to escape from local maximas. The different of this version and original *'hill climbing*', comes from 'choosing neighbors' step. This algorithm doesn't always choose the best neighbor, however with probability p does so, and with probability 1-p choose a random neighbor. This stochastic neighbor selection helps algorithm to be able to escape from getting stuck in local maximals. But as said before, this approach doesn't completely solve *'incompleteness'* problem of *'hill climbing'*
+
+##### 2.1.2.3 Random-restart hill climbing
+This version has been developed to solve *'local maxima'* problem. In this version we don't change the core of 'hill climbing', but we just run the original algorithm many times till we find the optimal goal. This version of *'hill climbing'* is complete with probability approaching 1, cause it will eventually generate a goal state as the initial state. If each run of *'hill climbing'* success with probabilty p, then the expected number of restarts we need will be 1/p.
+
+###### Example 2.1.3 (8-queens)
+Running 8-queens problem with this algorithm results as follow:
+- Without sideway moves: (p = 0.14)
+ - Expected number of iterations: 
+- With sideway moves: (p = 0.94)
+ - Expected number of iterations: 
+
+### 2.2 Tabu Search
+This algorithm is similar to *'hill climbing'* but uses a trick to prevent from stucking in local maxima. This is actualy a meta-heuristic algorithm that means it helps to guide and control actual heuristic. But how this strategy helps us to find global optimal?
+
+First of all, it has a list called 'tabu list' which has some states. Like hill climbing, from each state we are going to find its neighbors and choose one of them. But here we are not allowed to choose those states that are in tabu list, they are taboo. Also we don't stop if the best neighbor is not as good as current state, if it was so, we update best solution and move to that state and if it wasn't, we just move to the new state. The termination creteria can be a limitation on number of iterations. Below you can find a flowchart of this algorithm steps.
+
+
+
+Here we suppose to have a strategy to determine which states should be added to tabu list and which should take out of this list.
+
+### 2.3 Local Beam Search
+Imagine you are living on Kepler-442b (which is an Earth-like exoplanet) and you've found a wide plain that consists of treasure. But you don't know where the treasure is, and you just know how probable is a cell of this field to have treasure beneath it. What strategy do you adopt to find the most probable cell to have treasure?
+
+
+
+Ofcourse using *'hill climbing'* will be one of the answers but it might find local maxiam while you want to find global maxima. What about calling your friends and searching the field together? (and may or may not divide treasure with them)
+
+This will be a good strategy to search the field together (you and k-1 of your friends), in a way that each of you broadcasts the list of neighbors of his current cell to others, and you all have a shared list which consists of all neighbors all of you currently see. Then choose the best k neighbors and each of you visit one of these neighbors and again broadcast new neighbors and ... . Continue this approach till the best of k neighbors you choose is less than or equal probable to the best of your current cells.
+
+The strategy you adopt to find treasure is called *'Beam Search'*. The different of this algorithm and k run of parallel *'hill climbing'* is clear. In this algorithm you might continue searching by one of your friends neighbor cell but, in parallel *'hill climbing'* you just follow your path and starts from different part of the field.
+
+```
+function Local-Beam-Search(problem) return state
+ current[k] <- k-initial state
+ while True:
+ neighbors[k] <- k-best neighbors of all state in current[k]
+ if best_of(neighbor[k]) <= best_of(current[k]):
+ return best_of(current[k])
+ current[k] <- neighbors[k]
+```
+
+### 2.4 Simulated Annealing
+
+The Simulated Annealing (SA) algorithm is based upon Physical Annealing in real life. Physical Annealing is the process of heating up a material until it reaches an annealing temperature and then it will be cooled down slowly in order to change the material to a desired structure. When the material is hot, the molecular structure is weaker and is more susceptible to change. When the material cools down, the molecular structure is harder and is less susceptible to change.
+
+Simulated Annealing (SA) mimics the Physical Annealing process but is used for optimizing parameters in a model. This process is very useful for situations where there are a lot of local minima algorithms would be stuck at.
+
+
+ 
+
+
+In problems like the one above, if a local minima algorithm like Gradient Descent started at the starting point indicated, it would be stuck at the local minima and not be able to reach the global minima.
+
+#### 2.4.1 Algorithm
+
+0. Preparation
+ * Temperature reduction function
+1. Start with an initial solution s = S₀. This can be any solution that fits the criteria for an acceptable solution. We also start with an initial temperature T = t₀.
+2. Select a neighbour randomly among neighbourhood of the current solution. The neighbourhood of a solution are all solutions that are close to the solution. For example, the neighbourhood of a set of 5 parameters might be if we were to change one of the five parameters but kept the remaining four the same.
+3. Decide whether to move to the neighbour found in step 2. Mostly by calculating the difference in cost between the current solution and the new neighbour solution. if the difference in cost between the current and new solution is greater than 0 (the new solution is better), then accept the new solution. If the difference in cost is less than 0 (the old solution is better), then accept it by the probabilty function respected to the difference and T.
+4. Decrease the temperature according to temperature reduction function.
+5. Repeat steps 2, 3, 4 until the termination conditions are reached.
+
+
+ 
+
+
+##### Psudocode
+
+```
+ Simulated_Annealing(problem, schedule) returns a solution state
+
+ current = make_node(problem.initial_state)
+ for t = 1 to +INF:
+ T = schedule(t)
+ if T=0 then return current
+ next = a randomly selected successor of current
+ delta = next.value - current.value
+ if delta > 0 then current = next
+ else current = next only with probability of e^(delta/T)
+```
+
+#### 2.4.2 Temperature reduction function
+
+temperature reduction function determines how to reduce the temerature in each iteration. there are usually 3 main types of temperature reduction rules: (there are some arbitrary constants in most of temperature reduction functions which should be tuned)
+
+- Linear Reduction Rule: t = t - alpha
+- Geometric Reduction Rule: t = t * alpha
+- Slow-Decrease Rule: t = t/(1 + beta * t)
+
+The mapping of time to temperature and how fast the temperature decreases is called the Annealing Schedule.
+
+#### 2.4.3 Probabilty function
+
+Probabilty function determines chance of going to new neighbour. The equation has been altered to the following:
+
+
+ 
+
+
+Where the delta c is the change in cost and the t is the current temperature.
+
+#### 2.4.4 High vs. Low temperature
+
+Due to the way the probability is calculated, when the temperature is higher, is it more likely that the algorithm accepts a worse solution. This promotes Exploration of the search space and allows the algorithm to more likely travel down a sub-optimal path to potentially find a global maximum.
+
+
+ 
+
+
+When the temperature is lower, the algorithm is less likely or will not to accept a worse solution. This promotes Exploitation which means that once the algorithm is in the right search space, there is no need to search other sections of the search space and should instead try to converge and find the global maximum.
+
+
+ 
+
+
+So at first, the high temprature causes more bad moves and the acceptation probability drops slowly(low slope). and as the temperature decreases, the bad moves' probability converges to zero so fast(high slope).
+
+In this exmaple, SA is searching for a maximum. By cooling the temperature slowly, the global maximum is found.
+
+
+ 
+
+
+#### 2.4.5 Simulated Annealing in practice
+
+- Defining the schedulability
+There is only one theorem about this.
+
+- **Theorem:** If T is decreased sufficiently slow, global optima will be found approximately with probability of 1.
+
+- Convergence can be guaranteed if at each step, T drops no more quickly than C/logn, where C is a constant and problem dependent and n is the number of steps so far. In practice different Cs are used to find the best choice for problem.
+
+#### 2.4.6 Pros and Cons
+
+- **Positive points:**
+ - Easy to implement and use
+ - Provides optimal solutions to a wide range of problems
+
+
+- **Negative points:**
+ - Can take a long time to run if the annealing schedule is very long
+ - There are a lot of "tuneable" parameters in this algorithm
+
+#### 2.4.7 Applications:
+
+- [Traveling salesman](https://en.wikipedia.org/wiki/Travelling_salesman_problem)
+- [Graph partitioning](https://en.wikipedia.org/wiki/Graph_partition)
+- [Graph coloring](https://en.wikipedia.org/wiki/Graph_coloring)
+- [Scheduling](https://en.wikipedia.org/wiki/Scheduling_(computing))
+- [Facility layout](https://www.managementstudyguide.com/facility-layout.htm)
+- [Image processing](https://en.wikipedia.org/wiki/Digital_image_processing)
+- ...
+
+### 2.5 Genetic algorithms
+
+Genetic algorithms is a group of algorithms which are search heuristic that are inspired by Charles Darwin’s theory of natural evolution. These algorithms reflect the process of natural selection where the fittest individuals are selected for reproduction in order to produce offspring of the next generation.
+
+
+ 
+
+
+In a genetic algorithm, a population of candidate solutions (called individuals, creatures, or phenotypes) to an optimization problem is evolved toward better solutions. Each candidate solution has a set of properties (its chromosomes or genotype) which can be mutated and altered; traditionally, solutions are represented in binary as strings of 0s and 1s, but other encodings are also possible.
+
+The evolution usually starts from a population of randomly generated individuals, and is an iterative process, with the population in each iteration called a generation. In each generation, the fitness of every individual in the population is evaluated; the fitness is usually the value of the objective function in the optimization problem being solved. The more fit individuals are stochastically selected from the current population, and each individual's genome is modified (recombined and possibly randomly mutated) to form a new generation. The new generation of candidate solutions is then used in the next iteration of the algorithm. Commonly, the algorithm terminates when either a maximum number of generations has been produced, or a satisfactory fitness level has been reached for the population.
+
+#### 2.5.1 Algorithm
+
+0. Preparation
+ - Genetic representation
+ - Fitness function
+1. Initial population
+2. Selection
+3. Genetic operators
+ - Crossover
+ - Mutation
+4. Repeat 2 and 3 until Termination
+
+#### Psudocode
+
+ Genetic-Algorithm(population, Fitness-Fn) returns individual
+
+ repeat
+ new_population = empty_set
+ for i = 1 to Size(population) do
+ x = Random_Selection(population, Fitness_Fn)
+ y = Random_Selection(population, Fitness_Fn)
+ child = Reproduce(x, y)
+ if(small random probabilty) then child = Mutate(child)
+ add child to new_population
+ population = new_population
+ until some individual is fit enough, or enough time has elapsed
+ return the best individual in population, according to Fitness_Fn
+
+ Reproduce(x, y) returns an individual
+
+ n = length(x); c = random between 1 to n
+ return append(substring(x,1,c),substring(y, c+1, n))
+
+##### 2.5.1.1 Preparation
+
+###### Genetic representation
+In the genetic algorithms, An individual is characterized by a set of parameters (variables) known as Genes. Genes are joined into a string to form a Chromosome (solution). The genetic representation is the way that the individuals are modeled to be used in the algorithm. The most standard one which is used in the genetic algorithms is an array of bits. other representations can be true in some questions but the crossover or mutation will be more complex than array of bits.
+
+
+ 
+
+
+###### Fitness function
+The fitness function determines how fit an individual is (the ability of an individual to compete with other individuals). It gives a fitness score to each individual. The probability that an individual will be selected for reproduction is based on its fitness score.
+
+
+##### 2.5.1.2 Initial population
+
+The process begins with a set of individuals which is called a Population. The population size depends on the nature of the problem and often the initial population is generated randomly, allowing the entire range of possible solutions (the search space).
+
+##### 2.5.1.3 Selection
+
+The idea of selection phase is to select the fittest individuals and let them pass their genes to the next generation. Two pairs of individuals (parents) are selected based on their fitness scores. Individuals with high fitness have more chance to be selected for reproduction.
+Note that there exist both asexual and sexual reproduction which in asexual reproduction, the parents are not limited but in sexual reproduction, a child has a mother and a father so a woman can not be a child's father. thus the genetic operators of sexual reproduction is different. And also there are more selection methods which for more information you can follow link below:
+
+- [Roulette Wheel Selection](https://en.wikipedia.org/wiki/Fitness_proportionate_selection)
+- [Scaling Selection](https://link.springer.com/referenceworkentry/10.1007%2F978-0-387-31439-6_242)
+- [Tournament Selection](https://en.wikipedia.org/wiki/Tournament_selection)
+- [Rank Selection](https://en.wikipedia.org/wiki/Selection_(genetic_algorithm))
+- [Hierarchical Selection](https://link.springer.com/article/10.1007/BF00130162)
+
+
+##### 2.5.1.4 Genetic operators
+
+- ***Crossover***
+Crossover is the most significant phase in a genetic algorithm. For each pair of parents to be mated, a number of crossover points are chosen at random from within the genes. Offspring are created by exchanging the genes of parents among themselves until the crossover points are reached. The new offspring are added to the population and replace their parents.(population size must be fixed)
+
+
+ 
+
+
+
+ 
+
+
+
+ 
+
+
+- ***Mutation***
+In certain new offspring formed, some of their genes can be subjected to a mutation with a low random probability. This implies that some of the bits in the bit string can be flipped. Mutation occurs to maintain diversity within the population and prevent premature convergence.
+
+
+ 
+
+
+##### 2.5.1.5 Termination
+
+This generational process is repeated until the population converge or termination condition has been reached.
+
+##### Example 2.5.1: 8-Queens
+Put 8 queens in 8 * 8 board which queens cannot attack eachother.
+
+
+ 
+
+
+##### Preparations
+- **Genetic representation**: 8 byte array is used which indices of array show the columns and the values in the array show the rows(1 <= values <= 8) which queens exist. for example, array[i] = j means that a queen exists in (j, i) of the chess board. ([2, 4, 7, 4, 8, 5, 5, 2] for above figure)
+- **Fitness function**: Number of non-attacking pairs of queens. (24 for above figure)
+
+
+##### Initial population
+randomly POPULATION_SIZE individuals are created.
+
+
+##### Selection
+Each individuals have the probabilty according to their fitness((fitness of x) / total fitness of population). Then the parents are selected (number of popualtion should be fixed).
+
+
+
+##### Crossover
+New offspring are generated by selecting some genes from one parent and the rest from another.
+
+
+ 
+
+
+ ##### Mutation
+ With the propabilty of P, some genes of new children change.
+
+
+ 
+
+
+In the picture below overview of the solution has shown:
+
+
+ 
+
+
+#### 2.5.2 Pros and Cons
+
+- **Positive Points:**
+ - Random exploration can find solutions that local search can't (via crossover primarily)
+ - Appealing connection to human evaluation ("neural" networks, and "genetic" algorithms are metaphors!)
+
+
+- **Negative Points:**
+ - Large number of "tunable" parameters
+ - Lack of good empirical studies comparing to simpler methods
+ - Useful on some (small?) set of problems but no convincing evidence that GAs are better than hill-climbing with random restarts in general
+
+#### 2.5.3 Applications
+
+It has wide variety of applications in:
+- [Automotive Design](https://en.wikipedia.org/wiki/Automotive_design) ([Relation to simulated annealing](https://www.researchgate.net/publication/221182599_Application_of_Genetic_Algorithms_for_the_Design_of_Large-Scale_Reverse_Logistic_Networks_in_Europe's_Automotive_Industry))
+- [Finance and Investment Strategies](https://en.wikipedia.org/wiki/Investment_strategy) ([Relation to simulated annealing](https://www.wiley.com/en-us/Genetic+Algorithms+and+Investment+Strategies-p-9780471576792))
+- Encryption and Code Breaking ([Relation to simulated annealing](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.324.5081&rep=rep1&type=pdf))
+
+
+### 2.6 Large Neighbourhood Search
+
+Large Neighbourhood Search (LNS) is an iterative local search method for solving optimization problems using Contraint Programming(CP). The algorithm is as follows:
+
+- Start from initial solution S (obtained by CP search)
+- At each iteration of LNS:
+ - Randomly freeze some variables to take their value as in the current S.
+ - Perform CP search on the non-frozen variables in order to find a better solution, replacing S if found.
+ - Repeat from step 2 until a good enough solution is found.
+
+Since LNS requires an initial solution to start from, LNS cannot be directly applied to satisfaction problems, as the initial solution would be final solution. Therefore we have to soften some constraints in order to use LNS for satisfaction problems, so that an initial soft solution can be found and then improved gradually into an actual solution via LNS.
+
+#### 2.6.1 Softening constraints by penalties
+
+A generic way of softening is to replace some constraints by penalty functions, and try to minimize the total penalty. for example:
+
+- Hard constraint: x + y = z
+- Penalty: p = |x + y - z|
+
+##### Example 2.6.1: Sum Of Subsets Problem
+
+Given a set of positive integers a1, a2,…., an upto n integers. Is there a non-empty subset such that the sum of the subset is given as M integer? For example, the set is given as [5, 2, 1, 3, 9], and the sum of the subset is 9; the answer is YES as the sum of the subset [5, 3, 1] is equal to 9.
+
+
+Imagine the set is {10, 7, 5, 18, 12, 20, 15} and the sum is 30.
+
+##### Formulate the problem
+
+ - **Constraints**:
+ - x1 * a1 + x2 * a2 + .... + xn * an = M
+ - for each i, xi = {0, 1}
+
+ - **Softening constraints by penalties**:
+
+ - p = | x1 * a1 + x2 * a2 + .... + xn * an - M | => p = | x1 * 10 + x2 * 7 + x3 * 5 + x4 * 18 + x5 * 12 + x6 * 20 + x7 * 15 - 30|
+
+ - for each i, xi = {0, 1}
+
+##### Find an initial solution using softened constraints:
+
+- Because in our search there is no constraints to cause backtrack, the answer "for each i, xi = 1", is chosen.
+- the penalty is 57
+
+##### Freeze some variables randomly and repeat the constraint search to find lower(better) penalty than current penalty. when it is found, break and go to the next iteration.
+
+- Freeze {x1, x2, x3, x5, x7}
+- Constraint search for non-frozen variables ({x4, x6})
+
+
+ 
+
+
+So as you see, the lower penalty is found, so we update {x1, x2, x3, x4, x5, x6, x7} and p. Then go to the next iteration.
+
+We continue the second step until we reach a good enough penalty and the return the answer.
+
+#### 2.6.2 Pros and Cons:
+
+- **Positive points:**
+ - As shown in figure below for a problem like [car sequencing](https://perso.ensta-paris.fr/~diam/ro/online/cplex/cplex1271/OPL_Studio/opllanguser/topics/opl_languser_app_areas_CP_carpb.html), LNS can solve more instances in compare to hard constraint attitude.
+ - LNS can be quickly put together from existing components. an existing construction heuristic or exact method can be turned into a repair heuristic and a destroy method based on random selection is easy to implement. Therefore we see a potential for using simple LNS for benchmark purposes when developing more sophisticated methods.
+
+
+- **Negative points:**
+ - As shown in figure below, LNS takes longer runtime than hard constraint attitude.
+ - It seems that the initial solution found by LNS is very insufficent and moreover maybe the choices for better neighbourhoods are not well enough. It can be better if we combine some atrributes of backtrack and LNS in each step to reach the better condition. There is a version called Non-failing LNS which has done this and you can look for more details in this [link](https://www.youtube.com/watch?v=VKUxuBaBAkc).
+
+
+ 
+
+
+#### 2.6.3 Applications
+
+- [Routing problems](https://en.wikipedia.org/wiki/Vehicle_routing_problem) ([Relation to LNS](https://link.springer.com/chapter/10.1007/3-540-49481-2_30))
+- [Scheduling problems](https://www.quinyx.com/blog/scheduling-problems) ([Relation to LNS](http://kth.diva-portal.org/smash/record.jsf?pid=diva2%3A1530574&dswid=9745))
+
+## 3. Summary
+As mentioned before, local search methods can be used widely in search problems with very big search spaces. In such spaces, classic search algorithms cannot work efficiently due to their exponential usage of either memory or time. In contrast, local search methods have a very low memory usage of O(1) which is because of the irrelevance of the path to the current solution, and also the time complexity of these methods is O(T) which T is the number of iterations.
+
+Many local search algorithms have been introduced above, and many have been proved to be very efficient for optimization problems, Hill climbing for instance was a method to solve such problems. An important challenge for these optimization algorithms was the possibility of getting stuck in a local optimum, other methods like Simulated Annealing was proposed to face this challenge and have been shown to be effective.
+
+## 4. References
+
+- https://towardsdatascience.com/optimization-techniques-simulated-annealing-d6a4785a1de7
+
+- https://www.geeksforgeeks.org/genetic-algorithms/
+
+- https://github.com/chengxi600/RLStuff/blob/master/Genetic%20Algorithms/8Queens_GA.ipynb
+
+- https://en.wikipedia.org/wiki/Genetic_algorithm#Optimization_problems
+
+- https://www.youtube.com/watch?v=VKUxuBaBAkc
+
+- AI course at Sharif University of Technology (Fall 1400)
diff --git a/notebooks/5_local_search/latex1.png b/notebooks/5_local_search/latex1.png
new file mode 100644
index 00000000..7ef54056
Binary files /dev/null and b/notebooks/5_local_search/latex1.png differ
diff --git a/notebooks/5_local_search/latex2.png b/notebooks/5_local_search/latex2.png
new file mode 100644
index 00000000..2617610f
Binary files /dev/null and b/notebooks/5_local_search/latex2.png differ
diff --git a/notebooks/5_local_search/latex3.png b/notebooks/5_local_search/latex3.png
new file mode 100644
index 00000000..7df53bea
Binary files /dev/null and b/notebooks/5_local_search/latex3.png differ
diff --git a/notebooks/5_local_search/latex4.png b/notebooks/5_local_search/latex4.png
new file mode 100644
index 00000000..aefe05dd
Binary files /dev/null and b/notebooks/5_local_search/latex4.png differ
diff --git a/notebooks/5_local_search/local-beam.jpg b/notebooks/5_local_search/local-beam.jpg
new file mode 100644
index 00000000..07e45ea4
Binary files /dev/null and b/notebooks/5_local_search/local-beam.jpg differ
diff --git a/notebooks/5_local_search/matadata.yml b/notebooks/5_local_search/matadata.yml
new file mode 100644
index 00000000..a915abb6
--- /dev/null
+++ b/notebooks/5_local_search/matadata.yml
@@ -0,0 +1,32 @@
+title: Local Search
+
+header:
+ title: Local Search
+
+authors:
+ label:
+ position: top
+ content:
+ - name: Amirali Ebrahimzadeh
+ role: Author
+ contact:
+ - link: https://github.com/AmiraliE1380
+ icon: fab fa-github
+
+ - name: Hamidreza Dehbashi
+ role: Author
+ contact:
+ - link: https://github.com/hamiddeboo8
+ icon: fab fa-github
+
+ - name: Mohamad Javad Hezareh
+ role: Author
+ contact:
+ - link: https://github.com/MJavadHzr
+ icon: fab fa-github
+
+
+comments:
+
+ label: false
+ kind: comments
diff --git a/notebooks/5_local_search/metadata.yml b/notebooks/5_local_search/metadata.yml
deleted file mode 100644
index bbd941b8..00000000
--- a/notebooks/5_local_search/metadata.yml
+++ /dev/null
@@ -1,40 +0,0 @@
-title: LN | Local Search
-
-header:
- title: Local Search
-
-authors:
- label:
- position: top
- text: Authors
- kind: people
- content:
- - name: Mahsa Amani
- role: Author
- contact:
- - icon: fab fa-github
- link: https://github.com/mahsaama
- - icon: fas fa-envelope
- link: mailto:mahsa.ama1391@gmail.com
-
- - name: Mobina Poornemant
- role: Author
- contact:
- - icon: fab fa-github
- link: https://github.com/mbinapournemat
- - icon: fas fa-envelope
- link: mailto:Mobina.poornemat@gmail.com
-
- - name: Arman Zarei
- role: Author
- contact:
- - icon: fab fa-github
- link: https://github.com/armanzarei
- - icon: fas fa-envelope
- link: mailto:armanzarei1378@gmail.com
-
- - name: Hossein Aghamohammadi
- role: Supervisor
- contact:
- - icon: fas fa-envelope
- link: mailto:hsnam861@gmail.com
diff --git a/notebooks/5_local_search/pp.png b/notebooks/5_local_search/pp.png
new file mode 100644
index 00000000..25e44286
Binary files /dev/null and b/notebooks/5_local_search/pp.png differ
diff --git a/notebooks/5_local_search/pp2.png b/notebooks/5_local_search/pp2.png
new file mode 100644
index 00000000..db0d1c07
Binary files /dev/null and b/notebooks/5_local_search/pp2.png differ
diff --git a/notebooks/5_local_search/pp3.png b/notebooks/5_local_search/pp3.png
new file mode 100644
index 00000000..e13ea361
Binary files /dev/null and b/notebooks/5_local_search/pp3.png differ
diff --git a/notebooks/5_local_search/pp4.png b/notebooks/5_local_search/pp4.png
new file mode 100644
index 00000000..e588e7f9
Binary files /dev/null and b/notebooks/5_local_search/pp4.png differ
diff --git a/notebooks/5_local_search/tabu.png b/notebooks/5_local_search/tabu.png
new file mode 100644
index 00000000..19562c84
Binary files /dev/null and b/notebooks/5_local_search/tabu.png differ
diff --git a/notebooks/index.yml b/notebooks/index.yml
index 1b2133c0..8c39f07d 100644
--- a/notebooks/index.yml
+++ b/notebooks/index.yml
@@ -12,6 +12,7 @@ notebooks:
kind: S2021, LN, Notebook
- notebook: notebooks/5_local_search/
kind: S2021, LN, Notebook
+ #Fall 1400
- notebook: notebooks/6_search_in_continuous_space/
kind: S2021, LN, Notebook
- pdf: notebooks/7_CSP/index.pdf
@@ -54,4 +55,4 @@ notebooks:
kind: S2021, LN, Notebook
#- notebook: notebooks/17_markov_decision_processes/
- notebook: notebooks/18_reinforcement_learning/
- kind: S2021, LN, Notebook
\ No newline at end of file
+ kind: S2021, LN, Notebook