"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plot_results(best_solutions, times, \"Hill-Climbing Search\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Conclusions"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 47,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Simple\n",
+ "# ulysses16: 77.12 (UCS-BFS), 77.02 (A-Star)\n",
+ "# att48: 39236 (UCS-BFS), 47853 (A-Star)\n",
+ "# st70: 761 (UCS-BFS), time-out (A-Star)\n",
+ "\n",
+ "# Medium\n",
+ "# a280: 3088 (UCS-BFS), time-out (A-Star)\n",
+ "# pcb442: 58952 (UCS-BFS), time-out (A-Star)\n",
+ "\n",
+ "# Hard\n",
+ "# dsj1000: time-out (UCS-BFS), 542,620,572 (Hill-Climbing)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " 1. UCS is the slowest one, and gets the same result as BFS, DFS, DP
\n",
+ " 1. A-Star can only solve problems with number of cities < 50.
\n",
+ " 2. Hill-Climbing gets different results every time (Heuristic).
\n",
+ " 3. Hill-Climbing is the fastest one till now. (faster than Dynamic Programming, but worse results).
"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "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.5"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/Workshop - 3 (Game).ipynb b/Workshop - 3 (Game).ipynb
new file mode 100644
index 0000000..e855941
--- /dev/null
+++ b/Workshop - 3 (Game).ipynb
@@ -0,0 +1,122 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Create a terminal here"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "![](\"images/terminal.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Change working directory"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```bash\n",
+ "$ cd Workshop\\ -\\ 3\\ \\(Game\\)/\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "![](\"images/pwd.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Run the game"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```bash\n",
+ "$ python3 minimax.py\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "![](\"images/minimax.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```bash\n",
+ "$ python3 ab-pruning.py\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "![](\"images/ab-pruning.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Reading Materials"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "https://stackabuse.com/minimax-and-alpha-beta-pruning-in-python/"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "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.5"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/Workshop - 3 (Game)/ab-pruning.py b/Workshop - 3 (Game)/ab-pruning.py
new file mode 100644
index 0000000..348101a
--- /dev/null
+++ b/Workshop - 3 (Game)/ab-pruning.py
@@ -0,0 +1,191 @@
+# We'll use the time module to measure the time of evaluating
+# game tree in every move. It's a nice way to show the
+# distinction between the basic Minimax and Minimax with
+# alpha-beta pruning :)
+import time
+
+class Game:
+ def __init__(self):
+ self.initialize_game()
+
+ def initialize_game(self):
+ self.current_state = [['.','.','.'],
+ ['.','.','.'],
+ ['.','.','.']]
+
+ # Player X always plays first
+ self.player_turn = 'X'
+
+ def draw_board(self):
+ for i in range(0, 3):
+ for j in range(0, 3):
+ print('{}|'.format(self.current_state[i][j]), end=" ")
+ print()
+ print()
+
+ # Determines if the made move is a legal move
+ def is_valid(self, px, py):
+ if px < 0 or px > 2 or py < 0 or py > 2:
+ return False
+ elif self.current_state[px][py] != '.':
+ return False
+ else:
+ return True
+
+ # Checks if the game has ended and returns the winner in each case
+ def is_end(self):
+ # Vertical win
+ for i in range(0, 3):
+ if (self.current_state[0][i] != '.' and
+ self.current_state[0][i] == self.current_state[1][i] and
+ self.current_state[1][i] == self.current_state[2][i]):
+ return self.current_state[0][i]
+
+ # Horizontal win
+ for i in range(0, 3):
+ if (self.current_state[i] == ['X', 'X', 'X']):
+ return 'X'
+ elif (self.current_state[i] == ['O', 'O', 'O']):
+ return 'O'
+
+ # Main diagonal win
+ if (self.current_state[0][0] != '.' and
+ self.current_state[0][0] == self.current_state[1][1] and
+ self.current_state[0][0] == self.current_state[2][2]):
+ return self.current_state[0][0]
+
+ # Second diagonal win
+ if (self.current_state[0][2] != '.' and
+ self.current_state[0][2] == self.current_state[1][1] and
+ self.current_state[0][2] == self.current_state[2][0]):
+ return self.current_state[0][2]
+
+ # Is whole board full?
+ for i in range(0, 3):
+ for j in range(0, 3):
+ # There's an empty field, we continue the game
+ if (self.current_state[i][j] == '.'):
+ return None
+
+ # It's a tie!
+ return '.'
+
+ def max_alpha_beta(self, alpha, beta):
+ maxv = -2
+ px = None
+ py = None
+
+ result = self.is_end()
+
+ if result == 'X':
+ return (-1, 0, 0)
+ elif result == 'O':
+ return (1, 0, 0)
+ elif result == '.':
+ return (0, 0, 0)
+
+ for i in range(0, 3):
+ for j in range(0, 3):
+ if self.current_state[i][j] == '.':
+ self.current_state[i][j] = 'O'
+ (m, min_i, in_j) = self.min_alpha_beta(alpha, beta)
+ if m > maxv:
+ maxv = m
+ px = i
+ py = j
+ self.current_state[i][j] = '.'
+
+ # Next two ifs in Max and Min are the only difference between regular algorithm and minimax
+ if maxv >= beta:
+ return (maxv, px, py)
+
+ if maxv > alpha:
+ alpha = maxv
+
+ return (maxv, px, py)
+
+ def min_alpha_beta(self, alpha, beta):
+
+ minv = 2
+
+ qx = None
+ qy = None
+
+ result = self.is_end()
+
+ if result == 'X':
+ return (-1, 0, 0)
+ elif result == 'O':
+ return (1, 0, 0)
+ elif result == '.':
+ return (0, 0, 0)
+
+ for i in range(0, 3):
+ for j in range(0, 3):
+ if self.current_state[i][j] == '.':
+ self.current_state[i][j] = 'X'
+ (m, max_i, max_j) = self.max_alpha_beta(alpha, beta)
+ if m < minv:
+ minv = m
+ qx = i
+ qy = j
+ self.current_state[i][j] = '.'
+
+ if minv <= alpha:
+ return (minv, qx, qy)
+
+ if minv < beta:
+ beta = minv
+
+ return (minv, qx, qy)
+
+ def play_alpha_beta(self):
+ while True:
+ self.draw_board()
+ self.result = self.is_end()
+
+ if self.result != None:
+ if self.result == 'X':
+ print('The winner is X!')
+ elif self.result == 'O':
+ print('The winner is O!')
+ elif self.result == '.':
+ print("It's a tie!")
+
+
+ self.initialize_game()
+ return
+
+ if self.player_turn == 'X':
+
+ while True:
+ start = time.time()
+ (m, qx, qy) = self.min_alpha_beta(-2, 2)
+ end = time.time()
+ print('Evaluation time: {}s'.format(round(end - start, 7)))
+ print('Recommended move: X = {}, Y = {}'.format(qx, qy))
+
+ px = int(input('Insert the X coordinate: '))
+ py = int(input('Insert the Y coordinate: '))
+
+ qx = px
+ qy = py
+
+ if self.is_valid(px, py):
+ self.current_state[px][py] = 'X'
+ self.player_turn = 'O'
+ break
+ else:
+ print('The move is not valid! Try again.')
+
+ else:
+ (m, px, py) = self.max_alpha_beta(-2, 2)
+ self.current_state[px][py] = 'O'
+ self.player_turn = 'X'
+
+def main():
+ g = Game()
+ g.play_alpha_beta()
+
+if __name__ == "__main__":
+ main()
diff --git a/Workshop - 3 (Game)/minimax.py b/Workshop - 3 (Game)/minimax.py
new file mode 100644
index 0000000..9d59560
--- /dev/null
+++ b/Workshop - 3 (Game)/minimax.py
@@ -0,0 +1,204 @@
+# We'll use the time module to measure the time of evaluating
+# game tree in every move. It's a nice way to show the
+# distinction between the basic Minimax and Minimax with
+# alpha-beta pruning :)
+import time
+
+class Game:
+ def __init__(self):
+ self.initialize_game()
+
+ def initialize_game(self):
+ self.current_state = [['.','.','.'],
+ ['.','.','.'],
+ ['.','.','.']]
+
+ # Player X always plays first
+ self.player_turn = 'X'
+
+ def draw_board(self):
+ for i in range(0, 3):
+ for j in range(0, 3):
+ print('{}|'.format(self.current_state[i][j]), end=" ")
+ print()
+ print()
+
+ # Determines if the made move is a legal move
+ def is_valid(self, px, py):
+ if px < 0 or px > 2 or py < 0 or py > 2:
+ return False
+ elif self.current_state[px][py] != '.':
+ return False
+ else:
+ return True
+
+ # Checks if the game has ended and returns the winner in each case
+ def is_end(self):
+ # Vertical win
+ for i in range(0, 3):
+ if (self.current_state[0][i] != '.' and
+ self.current_state[0][i] == self.current_state[1][i] and
+ self.current_state[1][i] == self.current_state[2][i]):
+ return self.current_state[0][i]
+
+ # Horizontal win
+ for i in range(0, 3):
+ if (self.current_state[i] == ['X', 'X', 'X']):
+ return 'X'
+ elif (self.current_state[i] == ['O', 'O', 'O']):
+ return 'O'
+
+ # Main diagonal win
+ if (self.current_state[0][0] != '.' and
+ self.current_state[0][0] == self.current_state[1][1] and
+ self.current_state[0][0] == self.current_state[2][2]):
+ return self.current_state[0][0]
+
+ # Second diagonal win
+ if (self.current_state[0][2] != '.' and
+ self.current_state[0][2] == self.current_state[1][1] and
+ self.current_state[0][2] == self.current_state[2][0]):
+ return self.current_state[0][2]
+
+ # Is whole board full?
+ for i in range(0, 3):
+ for j in range(0, 3):
+ # There's an empty field, we continue the game
+ if (self.current_state[i][j] == '.'):
+ return None
+
+ # It's a tie!
+ return '.'
+
+ # Player 'O' is max, in this case AI
+ def max(self):
+
+ # Possible values for maxv are:
+ # -1 - loss
+ # 0 - a tie
+ # 1 - win
+
+ # We're initially setting it to -2 as worse than the worst case:
+ maxv = -2
+
+ px = None
+ py = None
+
+ result = self.is_end()
+
+ # If the game came to an end, the function needs to return
+ # the evaluation function of the end. That can be:
+ # -1 - loss
+ # 0 - a tie
+ # 1 - win
+ if result == 'X':
+ return (-1, 0, 0)
+ elif result == 'O':
+ return (1, 0, 0)
+ elif result == '.':
+ return (0, 0, 0)
+
+ for i in range(0, 3):
+ for j in range(0, 3):
+ if self.current_state[i][j] == '.':
+ # On the empty field player 'O' makes a move and calls Min
+ # That's one branch of the game tree.
+ self.current_state[i][j] = 'O'
+ (m, min_i, min_j) = self.min()
+ # Fixing the maxv value if needed
+ if m > maxv:
+ maxv = m
+ px = i
+ py = j
+ # Setting back the field to empty
+ self.current_state[i][j] = '.'
+ return (maxv, px, py)
+
+ # Player 'X' is min, in this case human
+ def min(self):
+
+ # Possible values for minv are:
+ # -1 - win
+ # 0 - a tie
+ # 1 - loss
+
+ # We're initially setting it to 2 as worse than the worst case:
+ minv = 2
+
+ qx = None
+ qy = None
+
+ result = self.is_end()
+
+ if result == 'X':
+ return (-1, 0, 0)
+ elif result == 'O':
+ return (1, 0, 0)
+ elif result == '.':
+ return (0, 0, 0)
+
+ for i in range(0, 3):
+ for j in range(0, 3):
+ if self.current_state[i][j] == '.':
+ self.current_state[i][j] = 'X'
+ (m, max_i, max_j) = self.max()
+ if m < minv:
+ minv = m
+ qx = i
+ qy = j
+ self.current_state[i][j] = '.'
+
+ return (minv, qx, qy)
+
+ def play(self):
+ while True:
+ self.draw_board()
+ self.result = self.is_end()
+
+ # Printing the appropriate message if the game has ended
+ if self.result != None:
+ if self.result == 'X':
+ print('The winner is X!')
+ elif self.result == 'O':
+ print('The winner is O!')
+ elif self.result == '.':
+ print("It's a tie!")
+
+ self.initialize_game()
+ return
+
+ # If it's player's turn
+ if self.player_turn == 'X':
+
+ while True:
+
+ start = time.time()
+ (m, qx, qy) = self.min()
+ end = time.time()
+ print('Evaluation time: {}s'.format(round(end - start, 7)))
+ print('Recommended move: X = {}, Y = {}'.format(qx, qy))
+
+ px = int(input('Insert the X coordinate: '))
+ py = int(input('Insert the Y coordinate: '))
+
+ (qx, qy) = (px, py)
+
+ if self.is_valid(px, py):
+ self.current_state[px][py] = 'X'
+ self.player_turn = 'O'
+ break
+ else:
+ print('The move is not valid! Try again.')
+
+ # If it's AI's turn
+ else:
+ (m, px, py) = self.max()
+ self.current_state[px][py] = 'O'
+ self.player_turn = 'X'
+
+def main():
+ g = Game()
+ g.play()
+
+if __name__ == "__main__":
+ main()
diff --git a/Workshop - 3 (LP).ipynb b/Workshop - 3 (LP).ipynb
new file mode 100644
index 0000000..213dabf
--- /dev/null
+++ b/Workshop - 3 (LP).ipynb
@@ -0,0 +1,252 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Make sure you run this at the begining**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "np.set_printoptions(suppress=True)\n",
+ "from scipy.optimize import linprog"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Feasible Example"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\\begin{align}\n",
+ "\\max f=4x_1+x_2 \\\\\n",
+ "\\text{s.t.} -x_1 + 2x_2 &\\leq 4 \\\\\n",
+ "2x_1 + 3x_2 &\\leq 12 \\\\\n",
+ "x_1 - x_2 &\\leq 3 \\\\\n",
+ "\\text{and } x_1, x_2 \\geq 0\n",
+ "\\end{align}"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "c = [-4, -1, 0, 0, 0]\n",
+ "A = [[-1, 2, 0, 0, 0], [2, 3, 0, 0, 0], [1, -1, 0, 0, 0]]\n",
+ "b = [4, 12, 3]\n",
+ "\n",
+ "x0_bounds = (0, None)\n",
+ "x1_bounds = (0, None)\n",
+ "x2_bounds = (None, None)\n",
+ "x3_bounds = (None, None)\n",
+ "x4_bounds = (None, None)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ " con: array([], dtype=float64)\n",
+ " fun: -17.999999976555795\n",
+ " message: 'Optimization terminated successfully.'\n",
+ " nit: 4\n",
+ " slack: array([5.8 , 0.00000002, 0. ])\n",
+ " status: 0\n",
+ " success: True\n",
+ " x: array([4.19999999, 1.2 , 0. , 0. , 0. ])\n"
+ ]
+ }
+ ],
+ "source": [
+ "res = linprog(c, A_ub=A, b_ub=b, bounds=[x0_bounds, x1_bounds, x2_bounds, x3_bounds, x4_bounds])\n",
+ "\n",
+ "print(res)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Infeasible Example"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\\begin{align}\n",
+ "\\min f = x_1 - 2x_2 + 3x_3 \\\\\n",
+ "s.t. -2x_1 + x_2 + 3x_3 & = 2 \\\\\n",
+ "3x_1 + 3x_2 + 4x_3 & = 1 \\\\\n",
+ "\\end{align}"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "c = [-1, 2, -3]\n",
+ "A = [[-2, 1, 3], [3, 3, 4]]\n",
+ "b = [2, 1]\n",
+ "\n",
+ "x0_bounds = (0, None)\n",
+ "x1_bounds = (0, None)\n",
+ "x2_bounds = (0, None)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "scrolled": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ " con: array([ 0. , -4.56053464])\n",
+ " fun: -0.6099904044751114\n",
+ " message: 'The algorithm terminated successfully and determined that the problem is infeasible.'\n",
+ " nit: 4\n",
+ " slack: array([], dtype=float64)\n",
+ " status: 2\n",
+ " success: False\n",
+ " x: array([0.2893146 , 0.75265113, 0.60865936])\n"
+ ]
+ }
+ ],
+ "source": [
+ "res = linprog(c, A_eq=A, b_eq=b, bounds=[x0_bounds, x1_bounds, x2_bounds,])\n",
+ "\n",
+ "print(res)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Assignment
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\\begin{align}\n",
+ "\\min f = 3x_1 - x_2 \\\\\n",
+ "s.t. 2x_1 + x_2 & \\geq 2 \\\\\n",
+ "x_1 + 3x_2 & \\leq 3 \\\\\n",
+ "x_2 & \\leq 4 \\\\\n",
+ "\\text{and } x_1, x_2 \\geq 0\n",
+ "\\end{align}"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "c = [-3, 1]\n",
+ "A = [[-2, -1], [1, 3], [0, 1]]\n",
+ "b = [-2, 3, 4]\n",
+ "\n",
+ "x0_bounds = (0, None)\n",
+ "x1_bounds = (0, None)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ " con: array([], dtype=float64)\n",
+ " fun: -8.999999998556428\n",
+ " message: 'Optimization terminated successfully.'\n",
+ " nit: 4\n",
+ " slack: array([4., 0., 4.])\n",
+ " status: 0\n",
+ " success: True\n",
+ " x: array([3., 0.])\n"
+ ]
+ }
+ ],
+ "source": [
+ "res = linprog(c, A_ub=A, b_ub=b, bounds=[x0_bounds, x1_bounds])\n",
+ "\n",
+ "print(res)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "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.5"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/Workshop - 4 (TSP SA).ipynb b/Workshop - 4 (TSP SA).ipynb
new file mode 100644
index 0000000..a34f740
--- /dev/null
+++ b/Workshop - 4 (TSP SA).ipynb
@@ -0,0 +1,1026 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Make sure you run this at the begining**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import sys\n",
+ "import math\n",
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "# Append template path to sys path\n",
+ "sys.path.append(os.getcwd() + \"/template\") "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from utils.load_data import load_data\n",
+ "from utils.load_data import log\n",
+ "from utils.visualize_tsp import plotTSP\n",
+ "from utils.tsp import TSP\n",
+ "from utils.tsp import TSP_Bench\n",
+ "from utils.tsp import TSP_Bench_ALL"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Workshop Starts Here"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "![\"TSP\"](\"images/tsp.jpg\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "![\"solutions\"](\"images/solutions.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Get familiar with your dataset"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "There are problems at different levels. **3 simple, 2 medium, 1 hard**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "scrolled": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "./template/data/medium/pcb442.tsp\n",
+ "./template/data/medium/a280.tsp\n",
+ "./template/data/hard/dsj1000.tsp\n",
+ "./template/data/simple/att48.tsp\n",
+ "./template/data/simple/ulysses16.tsp\n",
+ "./template/data/simple/st70.tsp\n"
+ ]
+ }
+ ],
+ "source": [
+ "for root, _, files in os.walk('./template/data'):\n",
+ " if(files):\n",
+ " for f in files:\n",
+ " print(str(root) + \"/\" + f)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ulysses16 = np.array(load_data(\"./template/data/simple/ulysses16.tsp\"))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[38.24, 20.42],\n",
+ " [39.57, 26.15],\n",
+ " [40.56, 25.32],\n",
+ " [36.26, 23.12],\n",
+ " [33.48, 10.54],\n",
+ " [37.56, 12.19],\n",
+ " [38.42, 13.11],\n",
+ " [37.52, 20.44],\n",
+ " [41.23, 9.1 ],\n",
+ " [41.17, 13.05],\n",
+ " [36.08, -5.21],\n",
+ " [38.47, 15.13],\n",
+ " [38.15, 15.35],\n",
+ " [37.51, 15.17],\n",
+ " [35.49, 14.32],\n",
+ " [39.36, 19.56]])"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "ulysses16[:]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.scatter(ulysses16[:, 0], ulysses16[:, 1])\n",
+ "for i in range(0, 16):\n",
+ " plt.annotate(i, (ulysses16[i, 0], ulysses16[i, 1]+0.5))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Naive Solution: In Order"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]\n"
+ ]
+ }
+ ],
+ "source": [
+ "simple_sequence = list(range(0, 16))\n",
+ "print(simple_sequence)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plotTSP([simple_sequence], ulysses16, num_iters=1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Naive Solution: Random Permutation"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[6, 1, 13, 11, 15, 14, 9, 8, 0, 12, 7, 5, 4, 3, 10, 2]\n"
+ ]
+ }
+ ],
+ "source": [
+ "random_permutation = np.random.permutation(16).tolist()\n",
+ "print(random_permutation)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plotTSP([random_permutation], ulysses16, num_iters=1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Best Solution"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "best_ulysses16 = [0, 13, 12, 11, 6, 5, 14, 4, 10, 8, 9, 15, 2, 1, 3, 7]\n",
+ "plotTSP([best_ulysses16], ulysses16, num_iters=1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Calculate Fitness (Sum of all Distances)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def dist(node_0, node_1, coords):\n",
+ " \"\"\"\n",
+ " Euclidean distance between two nodes.\n",
+ " \"\"\"\n",
+ " coord_0, coord_1 = coords[node_0], coords[node_1]\n",
+ " return math.sqrt((coord_0[0] - coord_1[0]) ** 2 + (coord_0[1] - coord_1[1]) ** 2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Coordinate of City 0: [38.24 20.42]\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Coordinate of City 0:\", ulysses16[0])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Coordinate of City 1: [39.57 26.15]\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Coordinate of City 1:\", ulysses16[1])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Distance Between 5.882329470541408\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Distance Between\", dist(0, 1, ulysses16))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def fitness(solution, coords):\n",
+ " N = len(coords)\n",
+ " cur_fit = 0\n",
+ " for i in range(len(solution)):\n",
+ " cur_fit += dist(solution[i % N], solution[(i + 1) % N], coords)\n",
+ " return cur_fit"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Order Fitness:\t 104.42225210207233\n",
+ "Random Fitness:\t 165.05253084971622\n",
+ "Best Fitness:\t 74.10873595815309\n"
+ ]
+ }
+ ],
+ "source": [
+ "print (\"Order Fitness:\\t\", fitness(simple_sequence, ulysses16))\n",
+ "print (\"Random Fitness:\\t\", fitness(random_permutation, ulysses16))\n",
+ "print (\"Best Fitness:\\t\", fitness(best_ulysses16, ulysses16))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Naive Random Model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import math\n",
+ "import random\n",
+ "from model.base_model import Model\n",
+ "\n",
+ "class MyRandomModel(Model):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ "\n",
+ " def init(self, nodes):\n",
+ " \"\"\"\n",
+ " Put your initialization here.\n",
+ " \"\"\"\n",
+ " super().init(nodes)\n",
+ "\n",
+ " def fit(self, max_it):\n",
+ " \"\"\"\n",
+ " Put your iteration process here.\n",
+ " \"\"\"\n",
+ " random_solutions = []\n",
+ " for i in range(0, max_it):\n",
+ " solution = np.random.permutation(self.N).tolist()\n",
+ " random_solutions.append(solution)\n",
+ " self.fitness_list.append(self.fitness(solution))\n",
+ "\n",
+ " self.best_solution = random_solutions[self.fitness_list.index(min(self.fitness_list))]\n",
+ " return self.best_solution, self.fitness_list"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tsp_file = './template/data/simple/ulysses16.tsp'"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[*] [Node] 16, [Best] 102.73430244116014\n",
+ "[*] Running for: 0.01 seconds\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = MyRandomModel()\n",
+ "best_solution, fitness_list, time = TSP_Bench(tsp_file, model, max_it=100)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[]"
+ ]
+ },
+ "execution_count": 21,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.plot(fitness_list, 'o-')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Simulated Annealing"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import math\n",
+ "import random\n",
+ "from model.base_model import Model\n",
+ "\n",
+ "class MySAModel(Model):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ "\n",
+ " self.iteration = 0\n",
+ "\n",
+ " def init(self, nodes, *args):\n",
+ " super().init(nodes)\n",
+ "\n",
+ " T, stopping_temperature, alpha = args\n",
+ "\n",
+ " self.T = math.sqrt(self.N) if T == -1 else T\n",
+ " self.alpha = 0.995 if alpha == -1 else alpha\n",
+ " self.stopping_temperature = 1e-8 if stopping_temperature == -1 else stopping_temperature\n",
+ "\n",
+ " self.T_save = self.T # save inital T to reset if batch annealing is used\n",
+ "\n",
+ " def initial_solution(self):\n",
+ " \"\"\"\n",
+ " Greedy algorithm to get an initial solution (closest-neighbour).\n",
+ " \"\"\"\n",
+ " cur_node = random.choice(self.nodes) # start from a random node\n",
+ " solution = [cur_node]\n",
+ "\n",
+ " free_nodes = set(self.nodes)\n",
+ " free_nodes.remove(cur_node)\n",
+ " while free_nodes:\n",
+ " next_node = min(free_nodes, key=lambda x: self.dist(cur_node, x)) # nearest neighbour\n",
+ " free_nodes.remove(next_node)\n",
+ " solution.append(next_node)\n",
+ " cur_node = next_node\n",
+ "\n",
+ " cur_fit = self.fitness(solution)\n",
+ " if cur_fit < self.best_fitness: # If best found so far, update best fitness\n",
+ " self.best_fitness = cur_fit\n",
+ " self.best_solution = solution\n",
+ " self.fitness_list.append(cur_fit)\n",
+ " return solution, cur_fit\n",
+ "\n",
+ " def p_accept(self, candidate_fitness):\n",
+ " \"\"\"\n",
+ " Probability of accepting if the candidate is worse than current.\n",
+ " Depends on the current temperature and difference between candidate and current.\n",
+ " \"\"\"\n",
+ " return math.exp(-abs(candidate_fitness - self.cur_fitness) / self.T)\n",
+ "\n",
+ " def accept(self, candidate):\n",
+ " \"\"\"\n",
+ " Accept with probability 1 if candidate is better than current.\n",
+ " Accept with probabilty p_accept(..) if candidate is worse.\n",
+ " \"\"\"\n",
+ " candidate_fitness = self.fitness(candidate)\n",
+ " if candidate_fitness < self.cur_fitness:\n",
+ " self.cur_fitness, self.cur_solution = candidate_fitness, candidate\n",
+ " if candidate_fitness < self.best_fitness:\n",
+ " self.best_fitness, self.best_solution = candidate_fitness, candidate\n",
+ " else:\n",
+ " if random.random() < self.p_accept(candidate_fitness):\n",
+ " self.cur_fitness, self.cur_solution = candidate_fitness, candidate\n",
+ "\n",
+ " def fit(self, max_it):\n",
+ " \"\"\"\n",
+ " Execute simulated annealing algorithm.\n",
+ " \"\"\"\n",
+ " # Initialize with the greedy solution.\n",
+ " self.cur_solution, self.cur_fitness = self.initial_solution()\n",
+ "\n",
+ " self.log(\"Starting annealing.\")\n",
+ " while self.T >= self.stopping_temperature and self.iteration < max_it:\n",
+ " candidate = list(self.cur_solution)\n",
+ " l = random.randint(1, self.N - 1)\n",
+ " i = random.randint(0, self.N - l)\n",
+ " candidate[i : (i + l)] = reversed(candidate[i : (i + l)])\n",
+ " self.accept(candidate)\n",
+ " self.T *= self.alpha\n",
+ " self.iteration += 1\n",
+ "\n",
+ " self.fitness_list.append(self.cur_fitness)\n",
+ "\n",
+ " self.log(f\"Best fitness obtained: {self.best_fitness}\")\n",
+ " improvement = 100 * (self.fitness_list[0] - self.best_fitness) / (self.fitness_list[0])\n",
+ " self.log(f\"Improvement over greedy heuristic: {improvement : .2f}%\")\n",
+ "\n",
+ " return self.best_solution, self.fitness_list"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tsp_file = './template/data/simple/ulysses16.tsp'"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Set hyper-parameters\n",
+ "T = -1\n",
+ "stopping_T = -1\n",
+ "alpha = 0.99"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[MySAModel] Starting annealing.\n",
+ "[MySAModel] Best fitness obtained: 74.19894280657067\n",
+ "[MySAModel] Improvement over greedy heuristic: 28.71%\n",
+ "[*] [Node] 16, [Best] 74.19894280657067\n",
+ "[*] Running for: 0.02 seconds\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = MySAModel()\n",
+ "best_solution, fitness_list, time = TSP_Bench(tsp_file, model, T, stopping_T, alpha, max_it=1000)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[]"
+ ]
+ },
+ "execution_count": 26,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.plot(fitness_list, 'o-')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Your Smart Model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import math\n",
+ "import random\n",
+ "from model.base_model import Model\n",
+ "\n",
+ "class MyModel(Model):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ "\n",
+ " def init(self, nodes):\n",
+ " \"\"\"\n",
+ " Put your initialization here.\n",
+ " \"\"\"\n",
+ " super().init(nodes)\n",
+ " self.log(\"Nothing to initialize in your model now\")\n",
+ "\n",
+ " def fit(self, max_it):\n",
+ " \"\"\"\n",
+ " Put your iteration process here.\n",
+ " \"\"\"\n",
+ " self.log(\"Naive Random Solution\")\n",
+ " self.best_solution = np.random.permutation(self.N).tolist()\n",
+ " self.fitness_list.append(self.fitness(self.best_solution))\n",
+ "\n",
+ " return self.best_solution, self.fitness_list"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Test your Model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tsp_file = './template/data/simple/ulysses16.tsp'"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[MyModel] Nothing to initialize in your model now\n",
+ "[MyModel] Naive Random Solution\n",
+ "[*] [Node] 16, [Best] 154.5735310725095\n",
+ "[*] Running for: 0.00 seconds\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = MyModel()\n",
+ "best_solution, fitness_list, time = TSP_Bench(tsp_file, model)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Test All Dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "./template/data/medium/pcb442.tsp\n",
+ "./template/data/medium/a280.tsp\n",
+ "./template/data/hard/dsj1000.tsp\n",
+ "./template/data/simple/att48.tsp\n",
+ "./template/data/simple/ulysses16.tsp\n",
+ "./template/data/simple/st70.tsp\n"
+ ]
+ }
+ ],
+ "source": [
+ "for root, _, files in os.walk('./template/data'):\n",
+ " if(files):\n",
+ " for f in files:\n",
+ " print(str(root) + \"/\" + f)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def plot_results(best_solutions, times, title):\n",
+ " fig = plt.figure()\n",
+ " nodes = [len(s) for s in best_solutions]\n",
+ " data = np.array([[node, time] for node, time in sorted(zip(nodes, times))])\n",
+ " plt.plot(data[:, 0], data[:, 1], 'o-')\n",
+ " fig.suptitle(title, fontsize=20)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tsp_path = './template/data'"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Random Search\n",
+ "[*] ./template/data/medium/pcb442.tsp\n",
+ "[*] [Node] 442, [Best] 721524.9399929157\n",
+ "[*] Running for: 0.42 seconds\n",
+ "\n",
+ "[*] ./template/data/medium/a280.tsp\n",
+ "[*] [Node] 280, [Best] 31159.560032157442\n",
+ "[*] Running for: 0.26 seconds\n",
+ "\n",
+ "[*] ./template/data/hard/dsj1000.tsp\n",
+ "[*] [Node] 1000, [Best] 524396404.5171182\n",
+ "[*] Running for: 0.87 seconds\n",
+ "\n",
+ "[*] ./template/data/simple/att48.tsp\n",
+ "[*] [Node] 48, [Best] 123105.46532911454\n",
+ "[*] Running for: 0.05 seconds\n",
+ "\n",
+ "[*] ./template/data/simple/ulysses16.tsp\n",
+ "[*] [Node] 16, [Best] 103.01947175501947\n",
+ "[*] Running for: 0.02 seconds\n",
+ "\n",
+ "[*] ./template/data/simple/st70.tsp\n",
+ "[*] [Node] 70, [Best] 3084.3745918065306\n",
+ "[*] Running for: 0.05 seconds\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = MyRandomModel()\n",
+ "\n",
+ "print(\"Random Search\")\n",
+ "best_solutions, fitness_lists, times = TSP_Bench_ALL(tsp_path, model)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plot_results(best_solutions, times, \"Random Model\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Set hyper-parameters\n",
+ "T = -1\n",
+ "stopping_T = -1\n",
+ "alpha = 0.8"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Simulated Annealing\n",
+ "[*] ./template/data/medium/pcb442.tsp\n",
+ "[MySAModel] Starting annealing.\n",
+ "[MySAModel] Best fitness obtained: 62562.051863573186\n",
+ "[MySAModel] Improvement over greedy heuristic: 0.02%\n",
+ "[*] [Node] 442, [Best] 62562.051863573186\n",
+ "[*] Running for: 0.09 seconds\n",
+ "\n",
+ "[*] ./template/data/medium/a280.tsp\n",
+ "[MySAModel] Starting annealing.\n",
+ "[MySAModel] Best fitness obtained: 3398.6263568993063\n",
+ "[MySAModel] Improvement over greedy heuristic: 0.00%\n",
+ "[*] [Node] 280, [Best] 3398.6263568993063\n",
+ "[*] Running for: 0.05 seconds\n",
+ "\n",
+ "[*] ./template/data/hard/dsj1000.tsp\n",
+ "[MySAModel] Starting annealing.\n",
+ "[MySAModel] Best fitness obtained: 24551747.27729817\n",
+ "[MySAModel] Improvement over greedy heuristic: 0.00%\n",
+ "[*] [Node] 1000, [Best] 24551747.27729817\n",
+ "[*] Running for: 0.33 seconds\n",
+ "\n",
+ "[*] ./template/data/simple/att48.tsp\n",
+ "[MySAModel] Starting annealing.\n",
+ "[MySAModel] Best fitness obtained: 39264.14564540566\n",
+ "[MySAModel] Improvement over greedy heuristic: 1.37%\n",
+ "[*] [Node] 48, [Best] 39264.14564540566\n",
+ "[*] Running for: 0.01 seconds\n",
+ "\n",
+ "[*] ./template/data/simple/ulysses16.tsp\n",
+ "[MySAModel] Starting annealing.\n",
+ "[MySAModel] Best fitness obtained: 76.04759446489814\n",
+ "[MySAModel] Improvement over greedy heuristic: 20.61%\n",
+ "[*] [Node] 16, [Best] 76.04759446489814\n",
+ "[*] Running for: 0.00 seconds\n",
+ "\n",
+ "[*] ./template/data/simple/st70.tsp\n",
+ "[MySAModel] Starting annealing.\n",
+ "[MySAModel] Best fitness obtained: 832.1275912241616\n",
+ "[MySAModel] Improvement over greedy heuristic: 4.06%\n",
+ "[*] [Node] 70, [Best] 832.1275912241616\n",
+ "[*] Running for: 0.01 seconds\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = MySAModel()\n",
+ "\n",
+ "print(\"Simulated Annealing\")\n",
+ "best_solutions, fitness_lists, times = TSP_Bench_ALL(tsp_path, model, T, stopping_T, alpha, max_it=1000)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {
+ "scrolled": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plot_results(best_solutions, times, \"Simulated Annealing Model\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Conclusions"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "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.5"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/Workshop - 5 (ACO, PSO).ipynb b/Workshop - 5 (ACO, PSO).ipynb
new file mode 100644
index 0000000..93e92a3
--- /dev/null
+++ b/Workshop - 5 (ACO, PSO).ipynb
@@ -0,0 +1,1022 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Make sure you run this at the begining**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import sys\n",
+ "import math\n",
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "# Append template path to sys path\n",
+ "sys.path.append(os.getcwd() + \"/template\") "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from utils.load_data import load_data\n",
+ "from utils.load_data import log\n",
+ "from utils.visualize_tsp import plotTSP\n",
+ "from utils.tsp import TSP\n",
+ "from utils.tsp import TSP_Bench\n",
+ "from utils.tsp import TSP_Bench_ALL"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Workshop Starts Here"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Get familiar with your dataset"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "There are problems at different levels. **3 simple, 2 medium, 1 hard**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "scrolled": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "./template/data/medium/pcb442.tsp\n",
+ "./template/data/medium/a280.tsp\n",
+ "./template/data/hard/dsj1000.tsp\n",
+ "./template/data/simple/att48.tsp\n",
+ "./template/data/simple/ulysses16.tsp\n",
+ "./template/data/simple/st70.tsp\n"
+ ]
+ }
+ ],
+ "source": [
+ "for root, _, files in os.walk('./template/data'):\n",
+ " if(files):\n",
+ " for f in files:\n",
+ " print(str(root) + \"/\" + f)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ulysses16 = np.array(load_data(\"./template/data/simple/ulysses16.tsp\"))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[38.24, 20.42],\n",
+ " [39.57, 26.15],\n",
+ " [40.56, 25.32],\n",
+ " [36.26, 23.12],\n",
+ " [33.48, 10.54],\n",
+ " [37.56, 12.19],\n",
+ " [38.42, 13.11],\n",
+ " [37.52, 20.44],\n",
+ " [41.23, 9.1 ],\n",
+ " [41.17, 13.05],\n",
+ " [36.08, -5.21],\n",
+ " [38.47, 15.13],\n",
+ " [38.15, 15.35],\n",
+ " [37.51, 15.17],\n",
+ " [35.49, 14.32],\n",
+ " [39.36, 19.56]])"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "ulysses16[:]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAD6CAYAAAC8sMwIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAb3ElEQVR4nO3dfXRV9b3n8feXgE6sYmQgEE/AqMjzQ8AIMnVQ6gRQGQS0DhlqYUCo3tIZqQW1XV0+rGthgRaxdunoQEXrlduOCCykIPIwVqsyATJAx0b0EgshQlCyLkIcIH7nj5wggQSSnId99snntVYW5+xzsveHh3zO5rd/e29zd0REJLzaBB1ARERioyIXEQk5FbmISMipyEVEQk5FLiIScipyEZGQU5GLSNKY2RIzO2hmu4LOkk4siHnkHTt29Ly8vKRvV0SCdeTIETIyMtizZw99+/YNOk7obN269ZC7dzpzedsgwuTl5VFcXBzEpkUkYGVlZYwZM0Yd0AJm9llDyzW0IiIScipyEZGQU5GLiAB79+5lxIgR9OnTh759+7Jo0aKgIzVZIGPkIiKppm3btjz11FMMHjyYI0eOcO2111JYWEifPn2CjnZe2iMXkaQpKipi2LBhlJaWkpuby+LFi4OOdEpOTg6DBw8G4JJLLqF3796Ul5cHnKpptEcuIgm1Yns5C9aVsr+qmssHTue5OU8yblAk6FjnVFZWxvbt2xk6dGjQUZpERS4iCbNiezkPL99J9YkaAMqrqnl4+U6AlC3zr776ijvuuIOnn36a9u3bBx2nSTS0IiIJs2Bd6akSr1N9ooYF60oDSnRuJ06c4I477mDSpElMmDAh6DhNpiIXkYTZX1XdrOVBcnemTZtG7969+elPfxp0nGZRkYtIwlyeldms5UF67733eOWVV9i4cSP5+fnk5+ezZs2aoGM1icbIRSRhZo/qWW+MHCCzXQazR/UMMNW36h2IzcrkjW37Unbs/lxU5CKSMHWleHpZzh7VMyXKMowHYhvT5CI3s67Ay0BnwIEX3H2RmT0KTAcqo2/9ubuH4/8jIpJw4wZFUrIYz3UgNhXznktz9shPAg+4+zYzuwTYambro68tdPcn4x9PRCQxwnQg9nyafLDT3SvcfVv08RHgIyBcH1siIlFhOhB7Pi2atWJmecAg4MPooplmtiN694/LGvmeGWZWbGbFlZWVDb1FRCRpZo/qSWa7jHrLUulAbHM0u8jN7GLgdeB+d/9X4DngaiAfqACeauj73P0Fdy9w94JOnc66wYWkua+//pohQ4YwcOBA+vbtyyOPPBJ0JGnlxg2KMHdCfyJZmRgQycpk7oT+oRsfh2bOWjGzdtSW+KvuvhzA3Q+c9vqLwOq4JpS0cOGFF7Jx40YuvvhiTpw4wQ033MAtt9zC9ddfH3Q0acVS9UBsczV5j9zMDFgMfOTuvz5tec5pbxsP6KaqchYz4+KLLwZqT4M+ceIEtf+kRCRWzRla+S5wN/A9MyuJft0KzDeznWa2AxgBzEpEUAm/mpoa8vPzyc7OprCwMDRXlhNJdU0eWnH3d4GGdqE0Z1yaJCMjg5KSEqqqqhg/fjy7du2iX79+QccSCT1da0WSLisrixEjRrB27dqgo4ikBRW5JEVlZSVVVVUAVFdXs379enr16hVsKJE0oWutSFJUVFQwefJkampq+Oabb7jrrrsYM2ZM0LFE0oKKXBLmzCvLPbJkdVpM9RJJNSpySYh0urKcSKrTGLkkRNhu8SUSZipySYh0urKcSKpTkUtCpNOV5URSnYpcEiKdriwnkup0sFMSIpVv8SWSblTkkjDpcmU5kVSnoRURkZBTkYs0Q2lpKfn5+ae+2rdvz9NPP53Qba5du5aePXvSvXt35s2bl9BtSThpaEWkGXr27ElJSQlQe1neSCTC+PHjE7a9mpoafvzjH7N+/Xpyc3O57rrrGDt2LH369EnYNiV8tEcu0kIbNmzg6quv5oorrkjYNrZs2UL37t256qqruOCCC5g4cSIrV65M2PYknFTkIi20bNkyioqKErqN8vJyunbteup5bm4u5eXlCd2mhI+KXKQFjh8/zqpVq/j+978fdBQRFblIS/zpT39i8ODBdO7cOaHbiUQi7N2799Tzffv2EYloSqfUpyIXaYHXXnst4cMqANdddx27d+9mz549HD9+nGXLljF27NiEb7elpk6dSnZ2dr1b+D366KNEIpFTM33WrNHdIeNNRS7STEePHmX9+vVMmDAh4dtq27Ytzz77LKNGjaJ3797cdddd9O3bN+HbbakpU6Y0eAu/WbNmUVJSQklJCbfeemsAydKbph+KnMeZN8iYPaonX3zxRRK3N5CPP/44YduLp+HDh1NWVhZ0jFZHe+Qi51B3g4zyqmqcb2+QsWJ7YmaOJHt7yfLss88yYMAApk6dyuHDh4OOk3aaXORm1tXMNpnZ/zWzv5rZf4su72Bm681sd/TXyxIXVyS5kn2DjHS8Icd9993Hp59+SklJCTk5OTzwwANBR0o7zdkjPwk84O59gOuBH5tZH+AhYIO7XwNsiD4XSQvJvkFGOt6Qo3PnzmRkZNCmTRumT5/Oli1bgo6Udppc5O5e4e7boo+PAB8BEeB2YGn0bUuBcXHOKBKYZN8gIx1vyFFRUXHq8RtvvFFvRovER4vGyM0sDxgEfAh0dve6v6nPgcROrBVJomTfICPsN+QoKipi2LBhlJaWkpuby+LFi5kzZw79+/dnwIABbNq0iYULFwYdM+2YuzfvG8wuBv4X8IS7LzezKnfPOu31w+5+1ji5mc0AZgB069bt2s8++yym4CLJ0tCslUReZz3Z24tV2PKGmZltdfeCs5Y3p8jNrB2wGljn7r+OLisFbnL3CjPLATa7+zl3HwoKCry4uLhZvwERST11s2xOP0Cb2S6DuRP6q8wToLEib86sFQMWAx/VlXjUKmBy9PFkQJdmE2kl0nGWTRg154Sg7wJ3AzvNrCS67OfAPOAPZjYN+Ay4K64JRSRlpeMsmzBqcpG7+7uANfLyzfGJIyJhcnlWJuUNlHaYZ9mEkc7sFJEWC/ssm3Sha62ISIvVHdDUrJVgqchFJCbjBkVU3AHT0IqISMipyEVEQk5FLiIScipyEZGQU5GLiIScilxEJORU5CIiIaciFxEJORW5iEjIqchFREJORS6SYqZOnUp2dna9e1vOnj2bXr16MWDAAMaPH09VVVVwASXlqMhFmqGhkv3lL3/JgAEDyM/PZ+TIkezfvz+mbUyZMoW1a9fWW1ZYWMiuXbvYsWMHPXr0YO7cuTFtQ9KLilykGRoq2dmzZ7Njxw5KSkoYM2YMjz/+eEzbGD58OB06dKi3bOTIkbRtW3uNu+uvv559+/adeq2hD5c//vGP9O3blzZt2qDbKqY/FblIMzRUsu3btz/1+OjRo9TeFTFxlixZwi233HLqeUMfLv369WP58uUMHz48oVkkNegytiJx8Itf/IKXX36ZSy+9lE2bNiVsO0888QRt27Zl0qRJp5YNHz6csrKyeu/r3bt3wjJI6tEeuUgcPPHEE+zdu5dJkybx7LPPJmQbL730EqtXr+bVV19N+F6/hIuKXCSOJk2axOuvvx739a5du5b58+ezatUqLrroorivX8JNRd7KNHRgrM5TTz2FmXHo0KEAkoXX7t27Tz1euXIlvXr1iml9RUVFDBs2jNLSUnJzc1m8eDEzZ87kyJEjFBYWkp+fz7333htrbEkjGiNvZaZMmcLMmTP54Q9/WG/53r17eeutt+jWrVtAycKhqKiIzZs3c+jQIXJzc3nsscdYs2YNpaWltGnThiuuuILnn3++2etdsb382/teDpzOc3OerHf7tGnTpsXztyFpRkXeyjR0YAxg1qxZzJ8/n9tvvz35oVJYvYLNymT2nCd57bX696eMtWRXbC/n4eU7qT5RA0B5VTUPL98J0KR7YTb04dKhQwd+8pOfUFlZyW233UZ+fj7r1q2LKaekriYXuZktAcYAB929X3TZo8B0oDL6tp+7+5p4h5TEWrlyJZFIhIEDBwYdJaXEWrBNtWBd6alt1Kk+UcOCdaWNbud8e/AA48ePj1tGSW3NGSN/CRjdwPKF7p4f/VKJh8yxY8f41a9+FfNJLOnoXAUbT/urqpu1vO4DpryqGufbD5gV28vjmkvCo8lF7u7vAF8mMIsE4NNPP2XPnj0MHDiQvLw89u3bx+DBg/n888+Djha45hZsS12eldms5cn6gJHwiMeslZlmtsPMlpjZZXFYnyRR//79OXjwIGVlZZSVlZGbm8u2bdvo0qVL0NEC19yCbanZo3qS2S6j3rLMdhnMHtWzwfcn6wNGwiPWIn8OuBrIByqApxp7o5nNMLNiMyuurKxs7G2SYA1NbZOGNbdgW2rcoAhzJ/QnkpWJAZGsTOZO6N/o+PjpHyTffP0VlW/8ivIX7+XAkn/g/fffj2s2CQdz96a/2SwPWF13sLOpr52poKDAdSGf5Dlr5sWonnE9WJfOUvHP7vSDsIfe/DUX5vYlu+BWHv+PPSnscRlZWVmB5pPGLVq0iBdffBF3Z/r06dx///3N+n4z2+ruBWcuj2n6oZnluHtF9Ol4YFcs65P4S9bMi3Q1blAk5f6c6vLMXbmV8r1/ZcB//jlzRvdKuZxS365du3jxxRfZsmULF1xwAaNHj2bMmDF079495nU3eWjFzF4D3gd6mtk+M5sGzDeznWa2AxgBzIo5kcSVDoylp3GDIvz3cd0Y1KMbPUpf4bGpY7jnnns4evRo0NGkER999BFDhw7loosuom3bttx4440sX748LutuzqyVInfPcfd27p7r7ovd/W537+/uA9x97Gl755IidGAsfZ08eZJt27Zx3333sX37dr7zne8wb968oGNJI/r168ef//xnvvjiC44dO8aaNWvYu3dvXNata62kuWTNvJDky83NJTc3l6FDhwJw5513sm3btoBTSWN69+7Ngw8+yMiRIxk9ejT5+flkZGSc/xubQEWe5pI186K1ycvLo3///uTn51NQcNaxp6To0qULXbt2pbS0dphsw4YN9OnTJ5As0jTTpk1j69atvPPOO1x22WX06NEjLuvVtVbSXN0BsFSbeZEONm3aRMeOHQPN8Jvf/IZJkyZx/PhxrrrqKn73u98FmkfO7eDBg2RnZ/P3v/+d5cuX88EHH8RlvSryViAVZ15IyzQ0HVJTecPjjjvu4IsvvqBdu3b89re/jdtUURW5SAuYGSNHjsTM+NGPfsSMGTMSvk1NJQ2fsz54n1mWkL8rFblIC7z77rtEIhEOHjxIYWEhvXr1SviNjltylUQJTjI/eHWwU6QFIpHaH8Ts7GzGjx/Pli1bEr5NTSUNl2Sew6EiF2mmo0ePcuTIkVOP33rrrQZvnRdvmkoaLsn84FWRizTTgQMHuOGGGxg4cCBDhgzhtttuY/Tohi7VH1+aShouyfzg1Ri5SBOcedDqsZfWJH1cWlNJw2X2qJ71xsghcR+8KnKR80il2SKaShoeyfzgVZGLnIdmi0hLJeuDN9Rj5DU1NQwaNIgxY8YEHUXSmGaLSKoLdZEvWrSI3r17Bx1D0pxmi0iqC22R79u3jzfffJN77rkn6CiS5jRbRFJdaMfI77//fubPn39qPq9Iomi2iKS6UBb56tWryc7O5tprr2Xz5s1Bx5FWQLNFJJWFcmjlvffeY9WqVeTl5TFx4kQ2btzID37wg6BjiYgEwtw96RstKCjweF16c/PmzTz55JOsXr06LusTEUlVZrbV3c+6k0ko98hFRORboRkjb+iC+uMGRbjpppu46aabgo4nIhKYUOyR150iXV5VjfPtKdIrtpcHHU1EpNkWLlxI37596devH0VFRXz99dcxra/JRW5mS8zsoJntOm1ZBzNbb2a7o79eFlOaRiTzur4iIolUXl7OM888Q3FxMbt27aKmpoZly5bFtM7m7JG/BJx5rc6HgA3ufg2wIfo87nSKtIikk5MnT1JdXc3Jkyc5duwYl19+eUzra3KRu/s7wJdnLL4dWBp9vBQYF1OaRugUaRFJF5FIhJ/97Gd069aNnJwcLr30UkaOHBnTOmMdI+/s7hXRx58DnWNcX4N0irSIpIvDhw+zcuVK9uzZw/79+zl69Ci///3vY1pn3A52eu2E9EYnpZvZDDMrNrPiysrKZq173KAIcyf0J5KViQGRrEzmTuivM+1EJHTefvttrrzySjp16kS7du2YMGECf/nLX2JaZ6zTDw+YWY67V5hZDnCwsTe6+wvAC1B7QlBzN6RTpEUkHXTr1o0PPviAY8eOkZmZyYYNGygoOOscn2aJdY98FTA5+ngysDLG9YmIpLWhQ4dy5513MnjwYPr3788333zDjBkzYlpnk/fIzew14Cago5ntAx4B5gF/MLNpwGfAXTGlERFJU/VParyRea/NiNsoQ5OL3N2LGnnp5rgkERFJU4m+72sozuwUEQmzRJ/UqCIXEUmwRJ/UqCIXEUmwRJ/UqCIXEUmwRJ/UGJrL2IqIhFWi7/uqIhcRSYJEntSooRURkZBTkYuIhJyKXEQk5FTkIiIhpyIXEQk5FbmISMipyEVEQk5FLiIScipyEZGQU5GLiIScilxEJORU5CIiIaciFxEJORW5iEjIqchFREJORS4iEnIqchGRkIvLHYLMrAw4AtQAJ929IB7rFRGR84vnrd5GuPuhOK5PRESaQEMrIiIhF68id+AtM9tqZjPitE4REWmCeA2t3ODu5WaWDaw3s7+5+zunvyFa8DMAunXrFqfNiohIXPbI3b08+utB4A1gSAPvecHdC9y9oFOnTvHYrIiIEIciN7PvmNkldY+BkcCuWNcrIiJNE4+hlc7AG2ZWt75/cve1cViviIg0QcxF7u7/AgyMQxYREWkBTT8UEQk5FbmISMipyEVEQk5FLiIScipyEZGQU5GLiIScilxEJORU5CIiIaciFxEJORW5iEjIqchFREJORS4iEnIqchGRkFORi4iEnIpcRCTkVOQiIiGnIhcRCTkVuYhIyKnIRURCTkUuIhJyKnIRkZBTkYuIhFxcitzMRptZqZl9YmYPxWOdIiLSNDEXuZllAL8FbgH6AEVm1ifW9YqISNPEY498CPCJu/+Lux8HlgG3x2G9IiLSBPEo8giw97Tn+6LLREQkCZJ2sNPMZphZsZkVV1ZWJmuzIiJpLx5FXg50Pe15bnRZPe7+grsXuHtBp06d4rBZERGB+BT5/wauMbMrzewCYCKwKg7rFRGRJmgb6wrc/aSZzQTWARnAEnf/a8zJRESkSWIucgB3XwOsice6RESkeXRmp4hIyKnIRURCTkUuIhJyKnIRkZBTkYuIhJyKXEQk5FTkIiIhpyIXEQk5FbmISMipyEVEQk5FLiIScipyEZGQU5GLiIScilxEJORU5CIiIaciFxEJORW5iEjIqcglbqZOnUp2djb9+vU7tezLL7+ksLCQa665hsLCQg4fPhxgQpH0pCKXuJkyZQpr166tt2zevHncfPPN7N69m5tvvpl58+YFlE4kfanIJW6GDx9Ohw4d6i1buXIlkydPBmDy5MmsWLEigGQi6U1FLgl14MABcnJyAOjSpQsHDhwIOJFI+lGRS9KYGWYWdAyRtKMil4Tq3LkzFRUVAFRUVJCdnR1wIpH0E1ORm9mjZlZuZiXRr1vjFUzSw9ixY1m6dCkAS5cu5fbbbw84kUj6icce+UJ3z49+rYnD+iSkioqKGDZsGKWlpeTm5rJ48WIeeugh1q9fzzXXXMPbb7/NQw89FHRMkbTTNugAEm4rtpezYF0p+6uquXzgdJ6b8yTjBkXqvWfDhg0BpRNpHeKxRz7TzHaY2RIzuywO65OQWLG9nIeX76S8qhoHyquqeXj5TlZsLw86mkirct4iN7O3zWxXA1+3A88BVwP5QAXw1DnWM8PMis2suLKyMl75JUAL1pVSfaKm3rLqEzUsWFcaUCKR1um8Qyvu/h+asiIzexFYfY71vAC8AFBQUOBNDSipa39VdbOWi0hixDprJee0p+OBXbHFkTC5PCuzWctFJDFiHSOfb2Y7zWwHMAKYFYdMEhKzR/Uks11GvWWZ7TKYPapnQIlEWqeYZq24+93xCiLhUzc75dSslaxMZo/qedasFRFJLE0/lJiMGxRRcYsETKfoi4iEnIpcRCTkVOQiIiGnIhcRCTkVuYhIyJl78k+yNLNK4LOkb7hxHYFDQYdohLK1TCpng9TOp2wtk4xsV7h7pzMXBlLkqcbMit29IOgcDVG2lknlbJDa+ZStZYLMpqEVEZGQU5GLiIScirzWC0EHOAdla5lUzgapnU/ZWiawbBojFxEJOe2Ri4iEXKsqcjP7N2a2xcz+j5n91cweO+P1Z8zsq1TKZmYvmdkeMyuJfuWnWD4zsyfM7GMz+8jM/msKZfvzaX9u+81sRQplu9nMtkWzvWtm3VMo2/ei2XaZ2VIzC+ziemaWYWbbzWx19PmVZvahmX1iZv9sZhcEla2RfDOj2dzMOiYtiLu3mi/AgIujj9sBHwLXR58XAK8AX6VSNuAl4M5U/bMD/gvwMtAm+lp2qmQ74z2vAz9MlWzAx0Dv6PJ/AF5KkWz/DtgL9IgufxyYFuC/u58C/wSsjj7/AzAx+vh54L6gsjWSbxCQB5QBHZOVo1XtkXutuj3udtEvN7MMYAEwJ9WyBZXnTOfIdx/wuLt/E33fwRTKBoCZtQe+B6xIoWwOtI8uvxTYnyLZaoDj7v5xdPl64I5kZwMws1zgNuB/RJ8btX+P/zP6lqXAuCCyRfPUywfg7tvdvSzZWVpVkcOp/wqVAAeB9e7+ITATWOXuFSmYDeAJM9thZgvN7MIUy3c18J+iN9b+k5ldk0LZ6owDNrj7v6ZQtnuANWa2D7gbmJcK2YAtQFszqzux5U6gaxDZgKep3bn6Jvr83wJV7n4y+nwfEOTF8J+mfr7AtLoid/cad88HcoEhZjYc+D7wm0CD0WC2fsDDQC/gOqAD8GCK5bsQ+Nprz2h7EViSQtnqFAGvBZELGs02C7jV3XOB3wG/ToVsQF9gIrDQzLYAR6jdS08qMxsDHHT3rcnedlOkWr5WV+R13L0K2ETtvUa7A5+YWRlwkZl9EmC007ONdveK6H+B/x+1P/BDgswG9fNRu1e0PPrSG8CAgGIBZ2UjesBpCPBmgLGAetluAQae9r+Gf6Z2bDowZ/ybe9/d/727DwHeoXY8P9m+C4yN/kwuo3ZIZRGQddrB11ygPIBs0EA+M/t9QFlaV5GbWSczy4o+zgQKga3u3sXd89w9Dzjm7kHMIGgo29/MLCe6zKgdItiV7GznykftuPOI6NtuJIAf+nNkg9qhgdXu/nWyc50j20fApWbWI/q2umWpkO1vZpYdXXYhtf8DfD7Z2dz9YXfPjf5MTgQ2uvskaj9s7oy+bTKwMtnZzpHvB0FkgdZ3z84cYGn04GYb4A/uvjrgTHUazGZmG82sE7UzDEqAe1Ms37vAq2Y2C/iK2rHflMgWfW0iAY0/RzX25zYdeN3MvgEOA1NTKNuC6NBBG+A5d98YQLbGPAgsM7N/BLYDiwPOU4/VTr+dA3QBdpjZGndP+M+EzuwUEQm5VjW0IiKSjlTkIiIhpyIXEQk5FbmISMipyEVEQk5FLiIScipyEZGQU5GLiITc/wdYchCIkkcAEgAAAABJRU5ErkJggg==\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.scatter(ulysses16[:, 0], ulysses16[:, 1])\n",
+ "for i in range(0, 16):\n",
+ " plt.annotate(i, (ulysses16[i, 0], ulysses16[i, 1]+0.5))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Naive Solution: In Order"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]\n"
+ ]
+ }
+ ],
+ "source": [
+ "simple_sequence = list(range(0, 16))\n",
+ "print(simple_sequence)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAD4CAYAAADxeG0DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAA6j0lEQVR4nO3deVhUZf/H8fcNIgguqCDuIJrmmua+t7j0lKWVltuTWmn5qFlZmVrxU9PMNjRNM0uzXLK0NLVyX0MUNfcdxB1RUZRNYO7fHwOEsijMcmbg+7ourpgzM+d8TPzO4V6V1hohhBDOy8XoAEIIISwjhVwIIZycFHIhhHByUsiFEMLJSSEXQggnV8SIi/r4+OiAgAAjLi2EEE5r165dl7XWvnceN6SQBwQEEBYWZsSlhRDCaSmlIrM7Lk0rQgjh5KSQCyGEk5NCLoQQTk4KuRBCODkp5EII4eSkkAshbGp+VBQBISG4bNxIQEgI86OijI5U4Bgy/FAIUTjMj4pi0NGjxJtMAEQmJTHo6FEA+vj5GRmtQJE7ciGEzYwJD88o4uniTSbGhIcblKhgkjtyIYTNnE5KyvZ4ZGICaqwCoHrp6nQM7EjH6h15OOBhShcrbc+IBYIUciGETZi0iSLJV0l2K5PlOR9XE082HMCa8DWcjDnJyV0nmblrZpbXubm40bF6R3OhD+xIHd86KKXsEd+pKCN2CGrSpImWKfpCFFy7zu+iyTdNwPdR3OuMIYl/i6+niwuzatXKto38VuotdpzbwZqTa1gTvoaQsyG5Xqd+ufp0COxAx8COtPNvh1dRrzzlnB8VxZjwcE4nJVHV3Z0JgYEO3XavlNqltW6S5bgUciGENXVf3J0lh5cAED86nqVXY61WLCOvRbI2fC1rws2F/mrC1RxfW8q9VMbdfIfADlTzrnbb3fydHbGQ+4eMI7C4kCulqgDzAD9AA7O01lOUUv8HDASi0146Wmu9KrdzSSEXouCJiIkgcGogANP+M40hzYbY9frxyfFsPb01425+b9TeXF9ftNVSbrllbY/3d3fnVMuWtoppkZwKeV7ayFOAEVrr3UqpEsAupdSatOe+0Fp/ao2gQgjn8+7ad/l428cARL8djY+nj90zeLp50ql6JzoEdmDwtcEcij5029eBSwdISEnIeP2tIqWyPU9OHbSO7J4Ludb6AnAh7fsbSqnDQCVbBRNCOL6rCVcpO7ksACNajuDTTta/n0tOTebE1RP/FuXL/xbnFFNKns5VsURF6vrWpY5vHX5wSeWqzjoCu6q7u7Wi202+Rq0opQKARkAo0BoYqpR6AQjDfNcek817BgGDAKpWrZrfvEIIBzEzbCaDVw4G4MSwE1QvU/2e3peQnMDRK0dvu1s+GH2QY1eO5TlDYOlA6vjWoY5PHfN/fetwv8/9lHAvcdf3Ns2hjXxCYGCecxgtz52dSqniwCZggtZ6qVLKD7iMud18PFBBa/1ibueQNnIhnFdiSiJeE70waRPdanVjTtc5HLlyJEtTRuT1bPdAyFV6Mc5cmO8rex8eRTxs8CcppKNWlFJuwArgL63159k8HwCs0FrXy+08UsiFcExaay7HX769KF8+xMFLB4mKy9saKUVdi1LHt05GU0b6V2DpQIq4yBSW/LC4s1OZx+18CxzOXMSVUhXS2s8BngYOWBpWCGEdWmvO3TiXpRnjUPQhriVey9O5XJQLJm3C28ObMW3HZBToKqWq4KJktQ8j5eVjsTXwX2C/UuqftGOjgV5KqYaYm1ZOAa9YMZ8QIpNUUyoR1yKyNGMcij5024iMe1HOq1yWZow6vnUo51XutvHWO87toPns5pi0id97/U6Xml2s/ccSFsrLqJWtQHZzY3MdMy6EyNmt1Fscv3L8tjvl9C9N3vqvqpaqmm3HX37XLtFa8/RPT7Ps6DLcXNyIHRVrs7ZqYRlpqBLCiuKT4zly2dzxd/DSwYyhcieunsjzuWqUqZFtYc7rNPT8OHn1JDW+rAHAjCdm8GqTV21+TZF/UsiFyMW1xGvZNmOciT2Tp/O4KJccR2QUdS1qo/T5M+KvEXy+3dwNduWdK5QplnXRK+FYpJCLQkNrzaW4S1k6/Q5FHyI6PvruJ8jE080z28Ic4B2Aq4urjf4EtnU5/jK+n/gCMLL1SCZ1mGRwInGvpJALm7H1GF2tNWdiz/zbjJFp1l9sUmyezlXao/RtHX7pX5VKVCoUy6ZO2zGNYX8MAyBieAQB3gHGBhJ5IoVc2ER+tvhKMaUQHhOebVNGUmre1r8oX7x8tiMyfL18LfuDFTAJyQl4TvQEoEedHizusdjgRCI/pJALm8hpi6/+e7fSN6R7ns8X4B2QbcdfKY/sFz4Sd/fr4V95ZvEzAIQNDKNxxcYGJxL5JYVc2EROK8ilpC0bWqtsrSzNGLXK1qKYWzF7xiyUUk2p1JpWi5MxJ2lYviG7Bu2SCT1OTgq5sAlvkogh6ypy/h7FOBVk/81MhFnImRBafdcKgJW9V/L4fY8bnEhYgxRyYVXJqcmU/rg0cd4tcK39Lqnq3x8xZ11ZriDQWtNlQRdWnVhFsSLFiBkZg3sR51uuVWRPfp8SVrPz3E6KfliUuOQ4Qp76kO/r1Mff3R2FedcVR95CqyA7fuU4LuNcWHViFbOfnE38mHgp4gWM3JELqxj4+0Bm756Nu6s7saNiKepalBbkPEJF2MfwP4czNXQqAFffuZrv6frCsUkhFxa5lniN0h+bi8PkDpN5u/XbBicSAJfiLuH3qflD9P127zPu4XEGJxK2JIVc5NvSw0t5dvGzgEwicSTB24N54683AIh8PZKqpWRHroJOCrnIM601LWa3YMf5HbSo1IK/X/q7UMx+dHRxt+Io/lFxAHrV68WCZxcYnEjYixRykScRMREETjWPPFn63FKerv20wYkEwC+HfqHHzz0A2D1oN40qNDI4kbAnKeTink3eNpmRa0cCEDMyBm8Pb2MDCVJMKVSfWp3T10/TtGJTtr+8XSb3FEJSyMVd3Uq9RfGJxUk2JTPwwYHMenKW0ZEEsPX0VtrOaQvAX33/olP1TgYnEkaRQi5ytf3sdlp+2xKAHS/voGmlpgYnElprOv3YibXhaynpXpLot6Mdbk1zYV9SyEWOBvw2gLl751K8aHGuvnMVN1c3oyMVekcuH6H29NoAzOk6h/4N+xsbSDgEKeQii5iEGMpMNu8K83mnz3mj5RsGJxIA/1v5P2aEzQDg2shrsvKjyCCFXNxm8cHFPP/L8wCcGn4Kf29/gxMZz9YbZNzteu9ULMOQufcDMPahsXzQ/gObXVs4JynkAjC3uzae1Zg9F/fQtmpbNvXfJGPDyd8GGda+3pATEeD7KGf6zqVyycpWv6ZwfjJOSXDy6klcxrmw5+IelvVcxuYBm6WIp8lpg4wx4eF2ux6uHvg3Gi9FXOTonu/IlVJVgHmAH6CBWVrrKUqpMsBPQABwCnhOax1j/ajCFiZumciY9WMAuP7udUq6lzQ4kWPJaYOMnI7b6nqRiQmosQovNy/aB7Snvb/568EKD0ontMhT00oKMEJrvVspVQLYpZRaA/QH1mmtJyml3gXeBUZaP6qwpqSUJDwmeAAwuMlgvnriK4MTOaaq7u5EZlNcdeJFjl4+Si2fWna5XgmdQDW/BuyL2seq46tYdXxVtu93Va48FPCQudAHtKdZpWZ4FPGwakbheJTW+dutRSm1DJiW9vWQ1vqCUqoCsFFrnetPd5MmTXRYWFi+risst+30NtrMaQPArkG7eLDCgwYnclx3tlkDFNEppByeBNHrANj36j7q+9W32fU8XVxyXMv9WuI1tp3exqbITWw8tZGd53fe9Rqtq7TOKPStqrSieNHiVskubE8ptUtr3STL8fwUcqVUALAZqAec1lp7px1XQEz64zveMwgYBFC1atXGkZGReb6usFzfpX2Zv38+pT1Kc+ntSxRxkf7uu8k8isQz9SZxR4M5+vxXXIm/krFtGlhvA2NrjpKJuxVHyNkQNp7ayKbITWw9vfWu72lSsUlG001b/7Z3XYrB3qN6CjOrFXKlVHFgEzBBa71UKXUtc+FWSsVorXNdvV7uyO3vSvwVfD7xAWDqY1MZ1nyYwYmclxpr7ghOfj+ZIi5F2HV+F02++fffVshLIbSo3MKoeHmSmJLIjnM72HRqE5sizV8pppRc31O/XP2MO/porwa8FXnxnn+DEJaxSiFXSrkBK4C/tNafpx07ijStOLSF+xfSe2lvAM68cUZGP1goITkBz4meFCtSjPgx8RnH90ftp8HMBhmPN/bbSPuA9kZEtJrk1GR2X9idUeQ3ndpEXHLcvy9ovhA8ymd5n7+7O6datrRj0sIhp0J+z8MP05pNvgUOpxfxNMuBfmnf9wOWWRJUWI/Wmvoz6tN7aW8eDngY0wcmKeJWUMytGDte3kFCSgKj143OOF7frz46SHN4yGEAHvr+IdRYxeqTqw1Kajk3VzeaV27OO63fYXKHyfSp3+f2F7iXy/Z9thrVI7J3z3fkSqk2wBZgP5D+e9RoIBRYDFQFIjEPP7ya27nkjtz2jl85Ts1pNQFY0WsFT9R8wuBEBc/odaP5aOtHOS4mdvLqSWp8WSPj8bKey3iq1lP2jJhvN5JuMPefuQSHBhMek3XM/JCmQxjWbBidj1/NdpSN3JHbhlU7Oy0lhdy2xm8azwcbzdO4Y9+NpYR7CYMTFVweH3qQlJpE/Oh4irkVy/Y1p6+f5v5p95OQkgDA4u6L6VG3hz1j5kprzcZTG5kSOoVlR7P+Qt3Ovx2vN3+dp2o9hauL623P5XWUjbCMFPJCIDElkWITzMVkWLNhTP3PVIMTFXwpphTcxpsn5Oig3P8tXbhxgXoz6nE1wfwL6/fdvueFB16wecY7nb9xnhk7ZxAcGszNWzdve65MsTK83vx1XmnyCuW8sm82uZOMWrEfKeQF3ObIzbSfa+5Y2/PKHhqWb2hsoELk2JVj1JpWi/4P9GdOtzl3fX10XDSNvm7EuRvnAPi6y9cMajzIJtmSU5NZengpU0KnEHI2JMvzPer0YHjz4bSq0kqWZXACUsgLsOd/fp7FhxZTzqsc5948J2PDDfBl6Je89udredqp52rCVVrMbsHxq8cBCO4czPAWwy3KcfDSQaaETuGb3d9kee5+n/t5vfnr9G3QF6+iXhZdRxhDCnkBdDn+Mr6f+ALw1eNfMbjpYIMTFW61vqzFsavHuPrOVUoXy3UqxW1ik2JpN6cde6P2AvDRox/xbpt37/q+u3VIDm06lGHNh1GzbM17/0MIhyaFvID5Ye8PvPCbuX313JvnqFiiosGJhNYal3HmEb2mD0x5bqqIuxVHh3kd2H5uOwDvt3ufsQ+NRSmV0SEZHBrM8qPLs7y3vX97hjcfnm2HpCg4pJAXECZtovb02hy7coxO1TvxZ58/pW3TgZy/cZ5Kn1fi0WqPsvaFtfk6R0JyAh3ndWTb2W3ZPp+fDklRMORUyKUx1Ylk3q/xjz5/8FiNxwxOJO5UsURFFj67kF5LerHowCJ61ut51/ekd0gGhwaz/ez2HF83uPFgpj0xDRcl2wiI28kduZN4f/37fLjlQwBujropnVUOruMPHVkbvpazb5ylUslKtz134NIBpmyfwuw9s7O8r7ZPbYY3H35bh2RyajJ9lvbh50M/A9D/gf7Mfmq2NKEUQtK04qTS1/UAeLPFm3zW+TODE4l7lb64VnDnYKbumGpxh2SqKZUXl73IvH3zAHi+7vP8+MyPMkqpEJFC7oQ2RGzgkXmPANZd81rYhtaaDac2MCV0SrYdkg8FPMTw5sN5suaTFt1Nm7SJISuHMHPXTACerPkkvzz3C0Vdi+b7nMI5SCF3Ms/+9CxLjyylcsnKnBp+Sn6NdkDnYs/x1c6vmBI65fYVAYGyxcoyvPlwavnU4vlfnmfKY1N4rflrVr2+1pq3Vr/F59vNa9h1qNaB33v/LjsCFWBSyJ3EpbhL+H1qnt48q8ssBjYeaHAiAeZ26iWHlzAldEq2HZLP1X2O4c2H07JyyyyjiAYsG8Dcf+ZydOhRm4zp1lrz/ob3mbBlAgCtKrdizQtr8HTztPq1hLGkkDuBuf/MZcCyAQBcGHGB8sWzrvMs7COvHZJ3c+dmFLagtWbilom8t+E9ABqVb8Sm/ptk0bQCRAq5AzNpEzWm1iDiWgRP3PcEK3qvMDpSoRKbFMucPXOYEjqFiGsRWZ63xgzJ9E5rd1d3Et9LtCTuPfk85HNGrB4BQK2ytQh5KSRPs02FY5JC7qAORR+i7ld1AVjddzUdq3c0OFHBZq8OyeyEnQ+j6TdNGdl6JJM6TLLquXMyY+cM/rfqfwBUKVmF3a/sxsfTxy7XFtYnhdwBjVo7iknbzP+g40bHSZumDeTWIenj6cPw5sMZ1HiQ3WZIjlk3holbJxL6cijNKjWzyzXh9mY7H08f9g/eL013TkgKuQOJT47Ha6K5bfWdVu/wccePDU5UMFjSIWlPnhM8SUhJyHUzClvJvH+rl5sXR4Yeke3/nIgUcgexNnwtHX8wN58cGHyAuuXqGpzIeeXWIVnHt05Gh6Sj/aaTl80obOXXw7/yzOJnAFAoTr52kmqlqxmSRdw7KeQO4KmFT/H7sd8J8A7g5GsnZc2MPLhbh+SwZsMY2myo0yzZmr6n6gsNXuD7p783LMcfx//g8QWPZzy21RBJYR1SyA108eZFKnxWAYDvnvqOAY0GGJzIsWmtWR+xnimhU/j92O9Znn8o4CFeb/46XWp2ceqJUtN3TGfoH0P5s8+fdK7R2dAs6yPW8+i8RzMey2+LjkkKuUFm757NwN/Nk3oujriIX3HZy/BO6R2SwaHBxCfH3/acER2S9lR7Wm2OXDnC1y+eYOLZS4bve7nt9DbazGmT8Xj3oN00qtDI7jlE9qSQ21mqKZWAKQGcjT1Lt1rd+LXnr0ZHcgjJqcn8cugXpoROIfRcaJbnHaVDMp2tNxbWWuMyoyPUegtc/51ab/RO9DvP7aTZ7H9H1YS8FEKLyi0MySL+ZXEhV0p9B3QBLmmt66Ud+z9gIBCd9rLRWutVdztXQS/kBy4doP4M8wJX615YxyPVHjE4kXH2R+1nSugUvt3zbZbn6vjW4fXmr9OnQR+H65AEcxEfdPQo8SZTxjFrFthUUypXEq5Qf/dBLqVm/dDyd3fnVMuWOWazx871ey/upeHXDTMeb+q/iXb+7ax+HXFvrFHI2wE3gXl3FPKbWutP8xKmIBfyt1a/xWch5qVmjRheZqT0Dsng0GBOXTuV5flhzYYxrNkw7it7n/3D5UNASAiRSUlZjpd1SeEd191E3YwiKi7tK+37S3GX8n6hdusgu45vbYLN5nbr+33up2XllrSs3JIrJRoy/mKCzT5gsnM4+jB1vqqT8XjNf9fQIbCDTa4lcmaVphWlVACwQgp5VnG34ij+UXEARrcZzYRHJxicyLacrUNSa82VhCucvHqS8JhwwmPCORlzkpMx5sdnY89mfdM9FNjslPMqh5+XH37F/fDz8qN88fK3PU7/r6+XL0VciuT4gVFSJ9D0zGeEnA25ve+g+ULwyDqZJ7c7eGs5cfUE93357wfx771+p0vNLja9pviXLbd6G6qUegEIA0ZorWOscE6n8teJv3hsvnnbtcNDDnO/z/0GJ7K+c7HnmL5zOlNCpxjaIXkj6Ya5AOdQkPPLVblSvUx1qpeuTmDpQAJLBzIpGaJNWV/r71GMU1Yc/z0hMDDbJpyvaj1In4ez7vvpsnEj2V39dDYfBtZWo0wNdJAm8lokNafV5MmFTwLwc4+f6V6nu82vL7JnaSGfAYwHdNp/PwNezO6FSqlBwCCAqlWrWnhZx6C15rH5j7H65Gpqlq3J4SGHC8TY8PQOyeDQYHac25Hl+efrPs/w5sNpUblFvjokE1MSiYiJuL0gXwvn5FVzQb6Veivf2f1L+VO9THUCvQPN/y0dmFGc87polF8ObeQTAgPznS876c0h6W3eOvEixS/9Tp9287N9fWX3opxJyvr/qKq7u1Vz5cbf25+k95I4F3uOejPq0ePnHgD88PQP9G3Q1245hJlFTSv3+tydCkLTSvpu6QDfd/ueFx54weBEObtbx9i+qH1MDZ2abYdkXd+6DG8+PEuHZIophchrkRl3xLf99+pJbty6ke+85YuXp3rp6rcV5PRiXM6rnF1Hs9irUzGzdeHr6PBDB77o/AWvt3g9y/Pqqw4ON8rlUtwlGs5syIWbFwBZS99WbNVGXkFrfSHt+zeA5lrru24b7uyFfGbYTAavHAzApbcu4evla3CinGU38sINE6Uiv+HyqUVZXl+zbE08inhwLvYcVxKu5Pu6ZYqVybgbTi/C6QW5YomKDtFu7sheWv4S3+35LktTXXpn+uTeu5h+Ocnwced3uhJ/hWazm2U0c335ny8Z2myowakKDmuMWlkIPAT4AFFAUNrjhpibVk4Br6QX9tw4ayFPNaVS6fNKRMVF0aNODxb3WGx0pLvKqSONxIsQ2ivX9xYvWjyjvfjOgly1VFXZI9LG7tyMYl/UPh6Y+QDvtX2P8Y+MNzhd7q4nXqfNnDYcuHQAgI87fMw7rd8xOJXzkwlBFso8nnZjv420D2hvbKB7lFPHmAJutm7mkOO3hVliSiLFJhTDzcWN+DHxhi+0lR83b93kke8fYef5nQAEtQ8iqH2QQ0z2ckY5FXLn75mzg9f/fD2jiCeMSXCaIg45d4BVdXeXIu7gPIp4EDYwjGRTMiU/KgmYf/6cSfGixdkxcAfxo+Np79+esZvG4jLOhZFrRmLETWRBJYU8FzeSbqDGKqaETiGofRA6SDvdDuUTAgPxdLn9r9kWIy+EbTSu2JjOgZ1JSEng6y5fO93PX7pibsXY2H8jiWMS+U+N/zD578m4jHNh2KphUtCtQJpWcrDq+CqeWPAE4PxLexox8kJYx+nrp/EP9qeIKkKKTikwO0klpybT85eeLD2yFIAXG73IN09+UyCG79qStJHfI601HeZ1YP2p9dTxrcP+wfvlh0sYQmuNyzjzz17K+ykUGV8EfB/Fv9H4AvOhnGpKpd9v/Zi/3zxmvle9Xsx7eh5FXKwxV7HgkTbye3A29iwu41xYf2o985+Zz8H/HZQiLgzT6rtWAFx95yquLq582mcP1HqLyKQkNBCZlMSgo0eZHxVlbFALuLq48uMzP5L6QSoDHxzIwgMLcRvvRrdF3UhOTTY6nsXmR0UREBKCy8aNBISE2OzvSqpUmmk7plHliyoAXH77Mr3r9zY4kSjMlhxawvaz21ny3JKMGalfRifcNgkIIN5kYkx4/pcmcBQuyoVZT87C9IGJ4c2Hs+zoMop+WJTOP3QmKcX2Sw/YQvocDnt88Bb6Qp5iSqHs5LIM+2MYvev1RgdpynqWNTqWKMRiEmLo/nN3WlRuQYB3AO+seQf/YH8iE7MfsWKPNVbsRSlF8GPBmD4wMarNKFaHr8Zjggdtv2ubZY0fRzcmPPy2iXhguw/eQt1GvufCHh6c9SAAWwZsoU3VNnd5hxC2ER4TzqIDi1h0YBH7L+3P9jVurZaQ7FYmy3F7rHpoFK01H27+kA82fgBA4wqN2dBvAyXcSxic7O7Uxg2YZ2zccRwwPfRQ/s4pnZ23G7JqCF/t/AqAxDGJuBex34JDovC6FHeJXw79wqIDi9hyekuOrxvcZDCvNH6FBn4NMibP2HqjC0f3ybZPeGeteXZobZ/a/P3S33h7eBsbKhtbIrfQbm47myw3LIU8TWxSLKUmlQLgw4c/ZEy7MYbkEM4lr0M4b966yfKjy1l0YFG267UDlPYoTc96PelZryetq7Tm7zN/025uu1zXJ5GhpP9uWg3m1S53DdrlEM2h0XHRlPv032WcZww4zohT5636wSuFHFh+dDldF3UF4Piw49QoU8PuGYTzye1OuIdPadaGr81oFkk2ZR1poVAZBbtz9c7Z/vaXPh3fx9OH6Lejszwvsvpuz3e8tPwlwLyZx75X9xmyublJm3hywZOsOmHe5XLrgK20rtoaMP/sjAo/yZnERKp4ePBRYHWLPngLdSHXWtN+bnu2nN5Cw/IN2T1ot6z1IO5JUkoSgaE7OJ+cmvXJbBYee/y+x3m+7vN0rdWVUh6l7vk6dy6QJe7dgv0L6LO0D2BeEuDwkMNULlnZLtfO/NtBbguDqbGKsIFhNK7Y2KLr2XKHIIeWPjMOYNGzi3i+3vMGJxL2pLXmasJVIq5FEBETQcS1CMJjwjMeh8eEk6qzKdKZ5bTlm4cf5988T4USFSzK+P769wHY++peKeL50Lt+b3rX782SQ0vo/nN3qnxRBVflyonXThDgHWCTa+46v4sm35jraduqbVnfb/1d/+72XNxjcSHPSYH+qQneHswbf70BwJV3rlCmWNYef+H4UkwpnI09ay7AacU4cyGOirNsXG6lEpWoVroa1byrEVg6kGre1TIeVyxRkeqhO7JdCtjf3cPiIn44+jAfbvmQt1q+RQO/Bhadq7B7ts6z6CDNymMr6bKwC9WmVAPg2NBjVtvw+1riNap+UTVj45Szb5ylUslK9/Tefy7+Y5UM2SmQhTw5NZmyk8ty49YN+j3Qj7nd5hodqdC7kXTjtrviiJgIwq/9W5gtGSPs7uqebSEOLB1IgHeAxSMbctpT09KFx1JNqRk703/S6ROLziX+9UTNJ9BBmrXha+n4Q0dqTjOvk3Rg8AHqlqubr3NqremztA8LDywEYHXf1XSs3jFP55BCngdh58No+k1TAP5+8W9aVimY42vtzaRNXLx5MeMuOPNdccS1CE5fP23R+X09fTOKceZCXM27GlVKVTF0E4s799S01miRwKnmD4K40XEWZxRZdQjsgA7SGcMB680w70K555U9NCzf8J7PM2/vPPr91g+A0W1GM+HRCfnKs+finny9714UqEL+yopXmLVrFkVcihA3Ok52sLlDYkpixj6b2d0VX0u8lu9zK1SOhbha6Wr4evo6dQdzHz8/qw7z+2bXN5y+fpp1L6wrEKsZOrK2/m3RQZrQs6G0+LYFjb5uBEDoy6E0q9Qsx/cdij5E3a/Md/D1y9Vn58Cd+Z5vElg6MGP7O1soEIX8euJ1vD/2BmDSo5MY2WaksYFsJL3j7s7Ousx3x3ftuMtFSfeS2bYTVytdjQDvACk4VnL+xnkGrRjEM7Wf4ZFqjxgdp9BoXrk5OkhnzOhuPrs5AJv7b6atf9uM18XdiuP+6fdzNvYsACdfO0lgacua0RqVbySFPDe/Hv6VZxY/A0D4a+FUK13N4ES5SzGlcOb6mWwLcXhMOJfiLll0/kolKpkLcTZtxhWKV5BNjw2mtabS5+bOsSXPLTE4TeHUqEIjdJDm4KWD1JtRzzwLE3O799IjS5kZNhOApc8t5enaT1vlmg3LN2TJYdv9fTttIdda0+rbVmw/t52mFZsS+nKo3X51j02Kva3TLnMhjoiJICEl/9txubu651iIq3lXy9PYZOF4OszrACCTfhxA3XJ10UGa41eOU3NaTTr92AmAx2s8zoreK6xaT/LSJp8fTlPIM09Nrujmyrm9YyF6O7/0+IVn6zybp3OZtIkLNy7k2DxxJvaMRVkzd9zdOYqiSskquLm6WXR+4Zx+P/o760+tZ8EzC/Dx9DE6jsC8WFn6qJaKJSpy8cZFVp1Yhcs4F5Y8t4Rnaj9jleukF3KttU1uOJ1iZmd2U6RJTeT/KpSgqdv1bO+Kryddz3e+zB13dxbiat7V8PH0ceqOO2F/6Wv8POD3AP+8+o/RcQq9pJQkmnzThAOXDgBw8H8HqeNrHgp6NvYsdabXyRgrPv+Z+RbvT5C+25OlE8iceop+QEhIthMyspsina6Ue6kcR1H4e/tLx52wq/Qp+KYPTHITYLDR60bz0daPAJjXbR7/feC/2b4u6mYUDWY2yOi3+vapb3mx0Yv5vq4aq/ijzx88VuOx/J/D0in6SqnvgC7AJa11vbRjZYCfgADgFPCc1jom3ylzkNPC+cqjPKYg2YFbOLaBvw8EzKMfpIgbZ/XJ1XT+sTMAfer34Yenf8j178OvuB9Rb0VxOf4yTb9pykvLX+Kl5S8x7T/TGNJsSL4y7Lmwx6JCnpO87BA0F7gzwbvAOq31fcC6tMdWV9U9+7GbOR0XwlGEng1l9u7ZTO4w2eIhbCJ/zsWeQ41VdP6xMyXdS3Jt5DV+fObHe/5Q9fH0IWJ4BDEjY6jtU5uhfwxFjVV8+venec5iq0lB91zItdabgat3HO4KfJ/2/fdAN+vEut2EwEA8XW6Pao0p0kLY0q3UW7T4tgWebp683fpto+MUOimmFNp814bKX5hXQgwbGMb1d6/ne+SXt4c3h4YcIvbdWBpXaMzba95GjVWM3zSee22ittU0fUv37PTTWl9I+/4ikOPUN6XUIKVUmFIqLDo6b0Ov+vj5MatWLfzd3VGYd9goLLuiCOflNdELgGsjrxkbpBD6eOvHuI13Y9uZbUx/fDo6SFtt5cES7iUIGxRG3Og42lZtywcbP8BlnAuj1o7KtaC7u7pz/Opxq2S4U546O5VSAcCKTG3k17TW3pmej9Fal77beRxhqzchbGnilomMWT/GKmtQi3u39fRW2s4xz9J84r4nWN5rOS7ZLUFsRYkpiXRd2JXV4asBeK3ZawQ/Fpyl6abF7BaEngtFW9Cvl1Nnp6V/wiilVIW0C1QALJuWKEQBcPzKccasH8P/mv5PiridRMdFo8aqjCJ+6a1LrOi9wuZFHMCjiAd//fcvbr13i261ujF1x1RcxrkwcPlATPrfIdONyjeyWQZL/5TLgX5p3/cDlll4PiGcmkmbMiaYTH98usFpCj6TNtFlQZeMvTK3DNiCDtL4evnaPYubqxu/9vyV5PeT6VWvF7P3zMZ1nCt9l/Yl1ZTKrbLmDZldNm4kICSE+VGWraOf2T0XcqXUQiAEqKWUOquUegmYBHRUSh0HOqQ9FqLQqjvdvFrejVE3DE5S8M3YOQPXca6sPL6Sjx79CB2kaVO1jdGxKOJShAXPLiD1g1RebPQi8/fPp8jMzsxNKAse5dFAZFISg44etVoxd4oJQUI4g/R1qy2d9CFyt/vCbhrPMjdZtanShg39Nzj0Fnlaa0ptWMUNF68sz/m7u3Oq5b3vmVBo9+wUwh6ibkbR77d+PFbjMSniNnI98TpVvqiSr23WjKSU4mY2RRxynuyYV7bvCRCiECj/WXkAVvVeZXCSgkdrTd+lffH+2Jsbt27wZ58/0UHaKYp4OltPapRCLoSFuizoAsCFERdkCr6V/bjvR1zGuTB//3zebf0uOkjTuUZno2Plma0nNUrTihAWWH1yNSuPr2RO1zmUL17e6DgFxuHowxkbU9crV4+wgWH53mbNEdhq39d0UsiFyKebt27S+cfO3FfmPvo37G90nAIh7lYctafXztgT4MSwE1QvU93gVNZh7X1fM5OmFSHyqcRHJQA4MvSIwUmcn9aaIauGUPyj4pyJPcOS55agg3SBKeK2JnfkQuTDa3+8BsDRoUftMnuwIPvtyG88/ZN5b8zBTQYz/fHp0teQR1LIhcij3Rd28+WOLxn30Dhqlq1pdBynFRETQeBUc2df5ZKVOTLkCF5Fsx+mJ3InhVyIPEhOTc6YjPJ++/cNTuOcklKSaPpNU/Zf2g/AgcEHqFuursGpnJv8TihEHvh8Yt40OXFMosFJnNN769/DY4IH+y/t5/tu36ODtBRxK5A7ciHu0echnxObFEvISyFOPRTOCGtOrqHTj50A6F2vd5526BF3J4VciHsQERPBiNUjGNBwAC0qtzA6jtM4f+M8lT43z8AsXrQ4Z944g7eHt7GhCiAp5ELchdY6o1Puu67fGZzGOaSYUnjk+0fYcnoLADsH7qRJxSxrPQkrkTZyIe6iySxzAZIt2+7NJ9s+wW28G1tOb2Haf6ahg7QUcRuTO3IhcvHTgZ/YfXE3vz3/W7437S0s/j7zN62/aw3A4zUe5/fev8sYezuRQi5EDq7EX6Hnkp60929P1/u7Gh3HYV2Ov4zvJ//uyBP1VhTlvMoZmKjwkY9LIXKQPtRwQ78NBidxTCZtouvCrhlFfHP/zeggLUXcAHJHLkQ2nvv5OcC8eYEMk8tqZthMBq8cDMDERyYyqu0ogxMVblLIhbjDhogN/HzoZ2Y8McOpNi+whz0X9vDgrAcBaFW5FRv7b8TN1c3gVEIKuRCZJCQn8Mi8R6hYoiKvNnnV6DgO43ridfyD/bmedB2AM2+coXLJyganEumkjVyITDwnegJw+vXTBidxDFprXvj1Bbw/9uZ60nX+6PMHOkhLEXcwckcuRJqRa0YC5kWcXF1cDU5jvPn75tP3174AjGw9kkkdJhmcSOTEKoVcKXUKuAGkAilaaxn9L5zK/qj9TP57MqPajCr0izgduXyE2tNrA1DHtw67Bu3Co4iHwalEbqx5R/6w1vqyFc8nhF2kmlJpMLMBABMfnWhwGuPEJ8dTZ3odIq9HAgVrm7WCTtrIRaFX+Qtze2/86HiDkxhDa82wP4bhNdGLyOuR/NLjF9lmzclY645cA6uVUhr4Wms9y0rnFcKmpu+YzsWbF9nUfxPF3IoZHcfulh1ZRrefugHwSuNXmPHEDBk374SsVcjbaK3PKaXKAWuUUke01pszv0ApNQgYBFC1alUrXVaI/Dsbe5ahfwylV71etPNvZ3Qcu8q8zVrFEhU5OvQoxYsWNziVyC+ltbbuCZX6P+Cm1vrTnF7TpEkTHRYWZtXrCpEXWmtcxplbFnWQdf8NOLKklCSaz27O3qi9AOwfvJ965eoZnErcK6XUruwGk1jcRq6U8lJKlUj/HugEHLD0vELYUts5bQG48s4Vg5PYzwcbPsBjggd7o/Yyp+scdJCWIl5AWKNpxQ/4Na1drQiwQGv9pxXOK4RN/HbkN7ad2cbi7ospU6yM0XFsbm34Wjr+0BGAnnV7suDZBdIOXsBYXMi11uHAA1bIIoTNXUu8xtM/PU2Tik3oUbeH0XFsKvM2a15uXpx986xss1ZAycxOUaiU/rg0ADte3mFwEttJMaXQYV4HNkVuAmSbtcJAxpGLQqP/b/0BODX8VIFtWvj0709xG+/GpshNTH1sqmyzVkjIHbkoFLad3sb3e78nuHMw/t7+RsexuszbrD1W/TFW9F4h68UUIlLIRYGXlJJEmzlt8PbwZniL4UbHsaor8Vfw/cQXjXkIpWyzVjhJ04oo8DwmmBd8in472uAk1mPSJrot6obPJz5oNJv6b5Jt1goxuSMXBVrQhiAA9ryyhyIuBePH/euwr3l1pXnTiw8f/pAx7cYYnEgYrWD8ZAuRjSOXjzBu8zheb/46Dcs3NDqOxf65+A+Nvm4EQMvKLdnUf5NssyYAKeSigDJpU8aa2l889oXBaSwTmxRLQHAAMYkxgHn3oiqlqhicSjgSaSMXBdJ9X94HwM1RNw1Okn9aa/r/1p9Sk0oRkxjDqt6r0EFairjIQu7IRYHz7e5vCY8JZ81/1+BV1MvoOPmyYP8C+iztA8Dbrd5mcsfJBicSjkwKuShQLty4wMu/v0zXWl3pENjB6Dh5dvTyUe6ffj8AtX1qs/uV3bLNmrgrKeSiwNBaU/HzigD81vM3Y8PkUXxyPPW+qkfEtQgAjg87To0yNQxOJZyFtJGLAqPTj50A86QYZ6G1Zvifw/Ga6EXEtQh+7vEzOkhLERd5InfkokBYdXwVa8PX8sPTPzjNpJjlR5fTdVFXAAY+OJCvu3xdYNeAEbYlhVw4vRtJN3hiwRPU9a1L3wZ9jY5zV5HXIgmYEgBAheIVODbsmGyzJiwihVw4vZKTSgLmbcsc2a3UW7SY3YI9F/cAss2asB5pIxdO7dUV5qnqx4cdd+hmiaANQbh/6M6ei3v47qnvZJs1YVVyRy6c1s5zO/l619d89OhHDts5uC58HR1+MA+DfL7u8yx8dqFDf+AI5ySFXDil5NRkms1uRlHXorzb5l2j42Rx4caFjKGQxYoU49yb5yhdrLTBqURBJYVcOKUSH5UA4MaoGwYnuV2KKYVOP3Riw6kNgHlLuaaVmhqcShR00kYunM6krZNISk1ix8s7KOpa1Og4GT4P+Ry38W5sOLWBKY9NQQdpKeLCLuSOXDiVE1dPMGrdKF5p/IrDFMntZ7fT8tuWAHSu3pmVvVfKNmvCrqSQC6ehtc5Y1XBml5kGpzFvs+b3qR+pOhWAiyMu4lfcz+BUojCyStOKUuoxpdRRpdQJpZTj9TyJAqHBjAYAxL4ba2gOkzbxzE/P4POJD6k6lY39NqKDtBRxYRiL78iVUq7AdKAjcBbYqZRarrU+ZOm5hUj3474fORB9gJW9V1LCvYRhOb7Z9Q2DVgwCYPzD43mv3XuGZREinTWaVpoBJ7TW4QBKqUVAV0AKubCK6Lho/vvrf+kY2JHH73vckAx7L+6l4dcNAWheqTlbBmyRbdaEw7BGIa8EnMn0+CzQ/M4XKaUGAYMAqlataoXLisKi3KfmRbD+6vuX3a8dmxRL4JRAriRcAWSbNeGY7Db8UGs9S2vdRGvdxNfX116XFU4ufXXA82+et+uMSK01A5YNoNSkUlxJuMLK3itlmzXhsKxxR34OyPzTXTntmBAWWRu+luVHlzP7ydlUKFHBbtdddGARvZb0AuCtlm/xSadP7HZtIfLDGoV8J3CfUqoa5gLeE+hthfOKQizuVhwdf+hINe9qvPTgS3a5ZuZt1mqVrcWeV/ZQzK2YXa4thCUsLuRa6xSl1FDgL8AV+E5rfdDiZKJQK/6ReX3uE6+dsPm1EpITqD+jPidjTgJwbOgx7it7n82vK4S1WGVCkNZ6FbDKGucS4o0/3wDg8JDDuCjbdeNorRmxegRfbP8CgMXdF9Ojbg+bXU8IW5GZncKh/HPxH4JDg/mg3Qfc73O/za6z4tgKnlz4JAAvP/gys7rMkuVlhdOSQi4cRoophUZfNwJg7MNjbXKNzNus+Xn5cXzYcUMnGAlhDVLIhcMo94l5vHjimESrn/tW6i1aftuS3Rd2A7Dv1X3U96tv9esIYQRZxlY4hODtwcQkxrDtxW24F3G36rnHbhyL+4fu7L6wm2+f+hYdpKWIiwJF7siF4U5dO8Ubf71Bvwf60apKK6udd0PEBh6Z9wgAPer04KfuP0k7uCiQpJALQ2mtqTalGgBzu821yjkv3rxIhc/ME4g8inhw7s1zlClWxirnFsIRSSEXhmo+27wsT8zIGIvPlWpKpfOPnVkXsQ6A0JdDaVapmcXnFcLRSRu5MMzPB39m5/mdLH1uKd4e3had64uQLygyvgjrItYR3DkYHaSliItCQ+7IhSGuJlzluV+eo02VNjxd++l8nyfzNmsdAzvyR58/ZJs1UehIIReGKDu5LACbB2zO1/uvJlyl/KflSTYlA3BhxAXKFy9vtXxCOBNpWhF21+sX88qCp18/nedRJCZtovvi7pSdXJZkUzIb+m1AB2kp4qJQkztyYVebIzez6OAipv1nWp7X9p69ezYDfx8IwNiHxvJB+w9sEVEIpyOFXNhNQnIC7ee2p5xXOYY0G3LP79sXtY8HZj4AQNOKTdn64laKuha1VUwhnI4UcmE3nhM9AfNuP/fiRtINqk+tTnR8NACRr0dStZRsEyjEnaSNXNjFqLWjAPMaJ3cbVaK15sVlL1JyUkmi46NZ0WsFOkhLERciB3JHLmzu4KWDTNo2ibdbvX3XNU5+OvATPZf0BODNFm/yWefP7BFRCKcmhVzYVKoplXoz6gEwuePkHF937Moxak2rBUDNsjX555V/ZJs1Ie6RFHJhU/7B/gDEjY7L9vmE5AQemPkAx68eB2SbNSHyQ9rIhc3MDJvJuRvnWP/CejzdPLM8P+KvEXhO9OT41eMsenYROkhLERciH+SOXNjE2dizDF45mO51uvNwtYdvey7zNmsvNnqR2U/OluVlhbCAFHJhdVprqnxhnuzzc4+fM46fvn46o6mlnFc5Tgw7IdusCWEFUsiF1T009yEALr99GTBvs9b6u9aEnQ8DYO+re2ng18CoeEIUOBa1kSul/k8pdU4p9U/a1+PWCiac07Ijy9h8ejMLn11IWc+yjNs0DvcP3Qk7H8bsJ2ejg7QUcSGszBp35F9orT+1wnmEk7ueeJ1uP3WjUflG+Hn5ocaa27271+7OTz1+wkVJ37oQtiBNK8Ii86OiGBMezumkJHTiRfB9lD0X1/HIvEco6lqUCyMuyDZrQtiYNQr5UKXUC0AYMEJrbfmeXcIpzI+KYtDRo8SbTOYDHuWh1lsAbH9qAs0rNzcwnRCFh9Ja5/4CpdYC2S32PAbYDlwGNDAeqKC1fjGH8wwCBgFUrVq1cWRkpAWxhSMICAkhMikpy3F/d3dOtWxpQCIhCjal1C6tdZM7j9/1jlxr3eEeL/ANsCKX88wCZgE0adIk908P4RROZ1PEczsuhLANS0etVMj08GnggGVxhDOp6u6ep+NCCNuwdBjBZKXUfqXUPuBh4A0rZBJOYkJgIJ4ut/8Iebq4MCEw0KBEQhROFnV2aq3/a60gwvn08fMDyBi1UtXdnQmBgRnHhRD2IcMPhUX6+PlJ4RbCYDJDQwghnJwUciGEcHJSyIUQwslJIRdCCCcnhVwIIZzcXafo2+SiSkUDjjRH3wfzUgOOSLLljyNnA8fOJ9nyxx7Z/LXWvnceNKSQOxqlVFh26xc4AsmWP46cDRw7n2TLHyOzSdOKEEI4OSnkQgjh5KSQm80yOkAuJFv+OHI2cOx8ki1/DMsmbeRCCOHk5I5cCCGcnBRyIYRwcoWqkCulPJRSO5RSe5VSB5VSY+94fqpS6qYjZVNKzVVKRSil/kn7auhg+ZRSaoJS6phS6rBS6jUHyrYl0/+380qp3xwo26NKqd1p2bYqpWo4ULZH0rIdUEp9r5QybJVUpZSrUmqPUmpF2uNqSqlQpdQJpdRPSqmiRmXLId/QtGxaKeVjtyBa60LzBSigeNr3bkAo0CLtcRPgB+CmI2UD5gLdHfX/HTAAmAe4pD1XzlGy3fGaJcALjpINOAbUTjv+P2Cug2RrBZwBaqYdHwe8ZODP3ZvAAmBF2uPFQM+072cCg43KlkO+RkAAcArwsVeOQnVHrs3S77jd0r60UsoV+AR4x9GyGZXnTrnkGwyM01qb0l53yYGyAaCUKgk8AvzmQNk0UDLteCngvINkSwVuaa2PpR1fAzxr72wASqnKwBPA7LTHCvPf4y9pL/ke6GZEtrQ8t+UD0Frv0VqfsneWQlXIIeNXoX+AS8AarXUoMBRYrrW+4IDZACYopfYppb5QShm2IWYO+aoDzyulwpRSfyil7nOgbOm6Aeu01rEOlO1lYJVS6izwX2CSI2QDdgBFlFLpMxS7A1WMyAYEY765MqU9Lgtc01qnpD0+C1QyIFe6YG7PZ5hCV8i11qla64ZAZaCZUqod0AP40tBgZJutHjAKuB9oCpQBRjpYPncgUZunJn8DfOdA2dL1AhYakQtyzPYG8LjWujIwB/jcEbIBdYGewBdKqR3ADcx36XallOoCXNJa77L3te+Fo+UrdIU8ndb6GrAB86bRNYATSqlTgKdS6oSB0TJne0xrfSHtV+AkzP/gmxmZDW7Ph/muaGnaU78CDQyKBWTJRlqHUzNgpYGxgNuy/Qd4INNvDT9hbps2zB0/cyFa67Za62bAZszt+fbWGngq7d/kIsxNKlMA70ydr5WBcwZkg2zyKaV+NChL4SrkSilfpZR32vfFgI7ALq11ea11gNY6AIjXWhsxgiC7bEeUUhXSjinMTQQH7J0tt3yY250fTntZewz4R59LNjA3DazQWifaO1cu2Q4DpZRSNdNeln7MEbIdUUqVSzvmjvk3wJn2zqa1HqW1rpz2b7InsF5r3Qfzh033tJf1A5bZO1su+foakQUK3+bLFYDv0zo3XYDFWusVBmdKl202pdR6pZQv5hEG/wCvOli+rcB8pdQbwE3Mbb8OkS3tuZ4Y1P6cJqf/bwOBJUopExADvOhA2T5JazpwAWZordcbkC0nI4FFSqkPgT3AtwbnuY0yD799BygP7FNKrdJa2/zfhEzRF0IIJ1eomlaEEKIgkkIuhBBOTgq5EEI4OSnkQgjh5KSQCyGEk5NCLoQQTk4KuRBCOLn/B14KGtJzkpaXAAAAAElFTkSuQmCC\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plotTSP([simple_sequence], ulysses16, num_iters=1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Naive Solution: Random Permutation"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[11, 9, 14, 2, 15, 10, 0, 5, 3, 4, 7, 1, 12, 13, 6, 8]\n"
+ ]
+ }
+ ],
+ "source": [
+ "random_permutation = np.random.permutation(16).tolist()\n",
+ "print(random_permutation)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plotTSP([random_permutation], ulysses16, num_iters=1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Best Solution"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "best_ulysses16 = [0, 13, 12, 11, 6, 5, 14, 4, 10, 8, 9, 15, 2, 1, 3, 7]\n",
+ "plotTSP([best_ulysses16], ulysses16, num_iters=1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Calculate Fitness (Sum of all Distances)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def dist(node_0, node_1, coords):\n",
+ " \"\"\"\n",
+ " Euclidean distance between two nodes.\n",
+ " \"\"\"\n",
+ " coord_0, coord_1 = coords[node_0], coords[node_1]\n",
+ " return math.sqrt((coord_0[0] - coord_1[0]) ** 2 + (coord_0[1] - coord_1[1]) ** 2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Coordinate of City 0: [38.24 20.42]\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Coordinate of City 0:\", ulysses16[0])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Coordinate of City 1: [39.57 26.15]\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Coordinate of City 1:\", ulysses16[1])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Distance Between 5.882329470541408\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Distance Between\", dist(0, 1, ulysses16))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def fitness(solution, coords):\n",
+ " N = len(coords)\n",
+ " cur_fit = 0\n",
+ " for i in range(len(solution)):\n",
+ " cur_fit += dist(solution[i % N], solution[(i + 1) % N], coords)\n",
+ " return cur_fit"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Order Fitness:\t 104.42225210207233\n",
+ "Random Fitness:\t 152.17750148686756\n",
+ "Best Fitness:\t 74.10873595815309\n"
+ ]
+ }
+ ],
+ "source": [
+ "print (\"Order Fitness:\\t\", fitness(simple_sequence, ulysses16))\n",
+ "print (\"Random Fitness:\\t\", fitness(random_permutation, ulysses16))\n",
+ "print (\"Best Fitness:\\t\", fitness(best_ulysses16, ulysses16))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Naive Random Model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import math\n",
+ "import random\n",
+ "from model.base_model import Model\n",
+ "\n",
+ "class MyRandomModel(Model):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ "\n",
+ " def init(self, nodes):\n",
+ " \"\"\"\n",
+ " Put your initialization here.\n",
+ " \"\"\"\n",
+ " super().init(nodes)\n",
+ "\n",
+ " def fit(self, max_it):\n",
+ " \"\"\"\n",
+ " Put your iteration process here.\n",
+ " \"\"\"\n",
+ " random_solutions = []\n",
+ " for i in range(0, max_it):\n",
+ " solution = np.random.permutation(self.N).tolist()\n",
+ " random_solutions.append(solution)\n",
+ " self.fitness_list.append(self.fitness(solution))\n",
+ "\n",
+ " self.best_solution = random_solutions[self.fitness_list.index(min(self.fitness_list))]\n",
+ " return self.best_solution, self.fitness_list"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "tsp_file = './template/data/simple/ulysses16.tsp'"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[*] [Node] 16, [Best] 114.07985427845105\n",
+ "[*] Running for: 0.01 seconds\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = MyRandomModel()\n",
+ "best_solution, fitness_list, time = TSP_Bench(tsp_file, model, max_it=100)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[]"
+ ]
+ },
+ "execution_count": 22,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAButElEQVR4nO29eZQkV3Um/r2MjNxq7e7qtbpFt0SrQQtSg8CAsI2BodmM2ox/Y/h5bDP2DOOf8dieYYTRMAbsMYNszYw9Xs/BBmPPYDBguZAxIAPigC1WQWkXLbXW7mp1d/VSa26xvN8fL+6LF5ERmRGRW1X2+87RUVdWVmasN7733e/eyzjn0NDQ0NAYLeSGvQEaGhoaGr2HDu4aGhoaIwgd3DU0NDRGEDq4a2hoaIwgdHDX0NDQGEHkh70BADAzM8P3798/7M3Q0NDQ2FT43ve+d45zvj3qdxsiuO/fvx/33HPPsDdDQ0NDY1OBMfZ03O+0LKOhoaExgtDBXUNDQ2MEoYO7hoaGxghCB3cNDQ2NEYQO7hoaGhojiA3hltHQGFXMzS/gtjuP4dRSDXumy7j5yCEcPTw77M3SuASgg7uGRp8wN7+AW25/ADXLAQAsLNVwy+0PAIAO8Bp9h5ZlNDT6hNvuPCYDO6FmObjtzmND2iKNSwk6uGto9AmnlmqpXtfQ6CV0cNfQ6BP2TJdTva6h0Uvo4K6h0SfcfOQQCkbwFiubBm4+cmhIW6RxKUEHdw2NPuHo4Vn8zEsvkz/PTpfxobdcq5OpGgOBdstoaPQRN+zfio/c/RT+5/9zHf7li/YOe3M0LiFo5q6h0UdYrhhAbznukLdE41KDDu4aGn2E7QX1pg7uGgOGlmU0NPoI2xHMvWnr4J4EuqK3d+jI3BljH2WMnWWMPai89jeMsXu9/55ijN2r/O4WxthxxtgxxtiRPm23hsamgO3JMpq5dwZV9C4s1cDhV/TOzS8Me9M2JZLIMh8D8Dr1Bc75T3HOr+ecXw/gbwHcDgCMsasAvBXA1d7f/AljzOjlBmtobCbYrifLaObeEbqit7foGNw5518HcCHqd4wxBuBfAfiE99JNAD7JOW9wzp8EcBzAS3q0rRoamw6WoxOqSaErenuLbhOqPwzgDOf8Me/nWQAnlN+f9F7T0LgkIROqmrl3hK7o7S26De5vg8/aU4Ex9g7G2D2MsXsWFxe73AwNjY0JW1oh+ZC3ZOPj5iOHUDaDKq6u6M2OzMGdMZYH8BYAf6O8vABgn/LzXu+1FnDOP8w5v4FzfsP27duzboaGxoYGuWUamrl3xNHDs/jQW67FZEmY+HZMFHVFbxfohrm/BsAPOOcnldfuAPBWxliRMXYAwEEA3+lmAzU0NjMooao192Q4engWv/jKKwAAf/5zN+jA3gWSWCE/AeCbAA4xxk4yxn7B+9VbEZJkOOcPAfgUgIcBfBHAOznnwfS3hsYlBEv73FPDdrSU1Qt0LGLinL8t5vW3x7z+QQAf7G6zNDRGA5RQ1cw9OfQx6w10+wENjT5CFjFp5p4YTY+x25q5dwUd3DU0+ghZxKRZaGJo5t4b6OCuodFH6N4y6WHrTpo9gQ7uGhp9hEyo6kCVGBTUKchrZIMO7hoafYS2QqaHrVs29AQ6uGto9BE6oZoeltTcNXPvBjq4a2j0EbYOVKmhp1f1Bjq4a2j0ETqhmh70QLR1cO8KOrhraPQRlh7WkRp+ElqvdrqBDu4aGn2Eo4d1pAYloTVz7w56huomgJ4ruXmhe8ukh7ZC9gY6uG9w0FxJGj9GcyUB6AC/CaCrLdNDPxB7Ax3cNzjazZXUwX3jg9in7XK4Lkcux/r2XaOywpMJVVcH926gg/sGh54rubmhWiCbjotSrj/z4kdphaenV/UGOqG6waHnSm5uOAr77Kdjpt0Kb7NBDxXvDXRw3+DQcyU3N9S2tVYfNeRRWuFZOk/RE+jgvsFBcyVV/Mqrn7vpltqXKqwBMfdRWuH5RUxalukGOrhvArz5uj0AgLe/fD8MBvzhXcdx4D3/gBtvvQtz85HzxzU2CGyHw/CSqJbdv2A1Sis83UmzN9AJ1U0AYn+Lq3WAMVSbmy9p1o2TI+nfbkS3iO1yVEwDqw0bTad/44RpP2/+zH2wHI7dUyX8+uueN/T9zwK/iKm7h+FGvB4GCc3cNwHoIv+nx87BCRV2bIakGTk5FpZq4PAfSklWHUn/tpvv6Cdsx0W5IBh1o8++7aOHZ3HZ1goA4HP/4RWbNpDR9d6NFXKjXg+DhA7umwB0sa/U7cjfb6Sk2dz8Am689a6AbNSNkyPp325Ut4jtcIwVxQJ5ENa+Ve8aqW/iAiCSY5pdyFgb9XoYJLQsswlAssxU2cRyzWr5/UZJmsV5rcM3GSHJQympC2SjukUs15Va+CAqLlfq4vqoxxzzzYBeMPeNej0MEpq5bwLQxf7aq3du6KRZHFsyWHRVZpKHUlIXyK6pUubv6CcEcxfnrN/WPstxUbfEd2zq4N6D6VWj5B7KCh3cNwHoIn/x/q340FuuRcEQp212uowPveXaDaOtxrEih/PMD6WkLpDn7Rpv+dthP/g457BdjnJBLJD7zdxXFdmOgvxmA+dcKWLKLsvcfOQQSmYwvA37ehg0tCyzCUDl2Pkcw9HDs7h9fgHLNQuffeeNQ96yIPZMl7EQEeBnp8t41784iP/06fvlz0mdC/Sed3/mfjQdF1sqJt7/41fL1+fmF3DrFx7B6ZUG8jmA4mea7+gXKPldIVmmz8x9te5Ldg17czJ3tRNkN8z96OFZrNSaeN8dDwPYGNfDoNGRuTPGPsoYO8sYezD0+n9gjP2AMfYQY+x3lddvYYwdZ4wdY4wd6cdGX2qgEva8x9gLRm5Ddsxrx7JfceV2AMC+rWXc/Z5XpbrJjh6exZYxEwDwrtceCgT2W25/AKdXGgD8wP6Ga3al/o5+gAJVpTgYzV1l7o1NytxV+2O3VsgbD4prbs9UaUNcD4NGEub+MQB/BOCv6AXG2I8BuAnAdZzzBmNsh/f6VQDeCuBqAHsAfJkxdiXnfFPSiI3ik6XlqekVwxTN3IZkZkcPz4Jzjv/4qfsAALPTJdx8RHitH3l2BUC2Qp6m7eLsqgjgKwo7jdL4AWEZ3Qgg5lkpDCa4q8dms2ruakVvtzmK9YZ42F2oNrv6nM2Kjsydc/51ABdCL/9/AG7lnDe895z1Xr8JwCc55w3O+ZMAjgN4SQ+3d2DYSD5ZYjDE3IsblLkDwJu8aloA+MKv/Yh8GJ5fEzdYlhv22eUauPdMUNlpnMa/2oi2jA4aUpYpkBWyz8G9pmjuG/DhnwSBXjxdHq817zqoWy5qzc15PLpB1oTqlQB+mDH2bcbY1xhjL/ZenwVwQnnfSe+1FjDG3sEYu4cxds/i4mLGzegfNpJP1pKyjMrck134Ub7zfkJ96Jzz2DYAnF8X/86iO5+86AfxFcUKGud8IHfKsEErrvIQNPfNmlBVR+t1O4lpTSEClyJ7zxrc8wC2AngpgJsBfIqxGL9bDDjnH+ac38A5v2H79u0ZN6Mzsga3fvpk026TLWWZdJr7MFYfgeC+1mz5dxY2tuAF90I+FyjkuvnIIZhG62V33d6p1N/RD5Clb2womvvmZKrqA7DbLprrTSW4r+ngnhQnAdzOBb4DwAUwA2ABwD7lfXu914aCboJbv3yyWbaJ2IzP3I1EmvswVh/qzXluTWHu3r+z2NtOLtWQY8AV28cD7PTo4VkcuXoXAIBBOCImS3nMTlcybn1vQQ9laYXsO3NXZZnNytzFMSuZOViauXeFrMF9DsCPAQBj7EoABQDnANwB4K2MsSJj7ACAgwC+04PtzIRuglu/uuxl2Sa6yImlEnPnvP3FP4wqvSBzV4O7uLkcl7f0x+mEkxer2DlZwraxQkCWAYDZLWUUjBye+NAbcPd7XoXpSmHD9AGXCVXvOupnV0hAyDLk7d6sCVVa7ZRNoweau38MLq5fesG9o1uGMfYJAK8EMMMYOwng/QA+CuCjnj2yCeDnuIg0DzHGPgXgYQA2gHcO0ynTTXCjROB//vR9sF3eM59slm2SzN2TZYr5HFwuNMkoWYIQ5zvvZ5WeuqKI0twBEfSMFOPmFi7WBCsv53F6pR743XLVwlTFBKmChXyuLUMepAOKHmJFMwcjx/raFRIQzH2qbMJ1rU2rudPKrlLIR7baSIO1hv/3Fy7B4J7ELfM2zvluzrnJOd/LOf8I57zJOf/XnPNrOOcv5Jzfpbz/g5zzKzjnhzjnX+jv5rdHt9LK0cOz2DNdxtaxQs98slm2yZJuGT+AAZ013GH0+FYTvYsRmjuQXndfWKph75YyJktmQJYBgOWahamyKX9ul48YdA5Cnrccg2mwvjcOW6lbmCiZKJq5zcvcpZTVPXNfbziYKOaRY8BFLcuMFm4+cgjFfHclyE3b7WlyKioJ2GmbHFmh6jN3oHMLWZriVPLev2Oi2Pd2BbGyTIC5Jw9ytuPi2eU6ZreUMVHKB+x+ALBUtTCtBHczn0Mz5vMHnYMgiSGfyw2k8Gy1bmOilEcxnywn0y364cRqKrUB3QZ3Oh5bKgXN3EcNRw/P4udvPCB/ztKLxXLcnianjh6exWuevzPVNtkhK2Qhn9x9cfTwLF74nC0AgD/+6Rf2vQiLtsnIMZlEBYTmPpahmOfMagOOy7F3SwWTJRM1ywnc9Es1C9MVP7iLGoB0XSj7lYNQV1yFvNH3fu6rHnMvmbm+V6j2axVEEmTJNOBypM7PqFhv2Bgv5bFlrKCZ+yjiun3TAICX7N+aSVpp2i4clwf8t91i+0QRAPDBn7gm0TZZISukz9yTsbN1r4BjudqdhpkEFMB2TZakFFNt2qg2Hdm5MQ0jIxuk0NxFEFddISs1S74OeJp7TBAddKdAumZMI4eCwfqe6F2t25gs5VEyjb4XMfVrFUTedpITuzlm600bY8U8tlYKMqF/KWHkg3vV87qeU2SBNGh4F1cv2TtdaEkZbNgKmVRzJ9S8Y7BS739wp22anS5LWYb2l4KomvDstLQ/ebEqPs+TZYBgIdNStYnpckH+3C6hOugchKM0fGv30OkVVuq2ZO79Tqj2axUUbtnQTSHTat3GeDGPrZq5jyaItWZ5cov2o73vj73oBb2ky3SyQkqfe0LNnbDuWcK6dR8kAQXWPdMlVJsOqk1bBvldk0HmnmRpH2DuJcHQ6SFlOS7Wm05AljENFms5PHp4Fh88eo38ebps9jUHoZ4308gNgLlbgrnnjb4nVPu1ClITqkB3hUzrDRHct4wVcGG9/9f+RsPIB/eq119iuWalZk62y2VPk17qpaRFp2XuskI1ZXCn5fNAgrtNwV3c5OdWm/LButt7jYJvkqX9wlINM+NFlEyjRZah/Qm4ZfJGWyvkG16wW/77ddfs6msOQrWw9pu5N2wHDdsVCdUBuGWyGAOSIMzcrS6mMa01iLmbuFhtdqwLGTWMfHBfVxoGpV2aqTdjL2+Wc6llmTBzp4HLybaJpKlhBPfFtYZ0yuz2NHcKvkmW9icv1jC7RXxWWJZZ8nIIKnPv5EpRA/+9J5YS7lU2qAlV02jvv+8W9MCbKJkotUne9srhcvTwLF7x3Bn587axQk9WQVZIc++m7e9aQ2juWyoFOC6PnUE8qhj54F5VOgSq1rwkUJfRvQruTduVQTZpcCb2YhpB5p7k4eC4XOqvgwjutE8UkM+tNeTDLCzLJFnak8cdgGTuJMtEM3fWNojSMn+6YuKxs2vywdcPOLKyuP/M3Q/uXkI14nrttcOlZjm4YvsYGAN+9mX7e7IKotVOuctOmpxzrDeEFXLrmMjJZK1SHXTzvV5h5IO7ytzT6u7qzdgrWUb126Zm7rn0mrsqe4RL9/uBhpJQBURwP7/WxHgxL5k33bCdEpyuy0Vw9z5r0vt7X5YRxzJpEZP4bnEsb3jOFjgux0OnVrrY2/YgC6uRYyj0WXOn4q5JWcTU+l29dLi4LseDCyt4+RUzOLhjHPMnLmbb8BBsJ+yWycbca5YDl0Mwdy+4Z+kvs5Faf6fF6Af3hg0vJgYKaZKg0QdZRl09JH1gEJsxQsE9ycNBXbkMMqFKtsdzq02cX29g23hBrjwoyMkiK68fyp7pklzaz80v4OW33oWm7eKT3z2BufkFjBXyYCxKlgm5ZdrJMt7vXvScrQCA+/oozagW1k5tEbpFmLlHrQp76XB58vw61ho2rt07hcP7tuDeE0s90bRplSo194zHjJqGkRUSyNYZciO1/k6LkQ/u1aYtl/mpmbvTe+auBvfEzN3lyOeY7J/ia+4JgntTZe791xxpn8YLeUyVTcnct435wb2puFmOHp7Fy68Q2u2X/9OPysAuxueJPjLLNQu33P4A7rjvFCaKeamd0sNqOuxzbxMQVDfP7qkS7j+53Ktdb4FqYe13hSox94mSiWI+mrn30uFy/8klAMAL9k7h+sumsVS18NT5aurPCYNkM3LLZNXcaVDHRNGXZbIw92E03+sVRj64rzcc7JosoWDkAv1NkkBlDb1qQUAPGNNgyZm7y2UyFUinuVNP68lS942YkqBpuzANhlyOYWa84GnuDWwbL6KQF/sQZmO0H1RV2Y4tTZbNFuauFjGZRq5t50n67mI+h+v2TuM+L0j1AwErZD7X194y9OBux9x76fO//+QyyqaB524fx+HLpgEA9/ZAmgkXMWVd7ZD9d6zYneY+6MK3XmLkg3vVq1LbNl4IlMMnQdAt01vmvmuqlNzn7rjSBgmkq1Cl8WK7p8oDSqi6KHgMfWa8KJj7ehMzEbIMgY5zEhfNRMkMMPeJUl7KVYD/4ItbztN3mUYOeQN4+ny1b4kyR7Gw9pu5ryiaeylvwHJaH3Akg1HuolIwMjtcHji5jKv3TCJv5HBwxwTGCgbmn1nqej/8rpDE3LMds1WvI+R4MY9KwUAhn8vE3Ptl+RwERj64rzcdjBUNbPNYZBoEE6o9Yu7rTRTzOWwdKyZmJbaTnbmTLLN7uoSa5UT+TS/dAE3blds3M1HE2dUGLqw3sW2sGBvcqQo4bKMMY483jEN1y6g2SADywRL34KTv/u5TF/CPD4nRv/1KlBELNQzW0cXTCZ3OEWnu46V8257uRw/P4u0v3w8AOHzZdKbAbjsuHjq1gmu9iVdGjuEFe6d7Yi2VbpkuE6rE3MeLeTDGsLVSyMTcjx6elS4vQLQO6XfzvV5h5IN7tWGjUshjZryI8ylPrnoz9oy5rzYwM15EMZ9LLPXYriuHYwPp3DJk9SOPeZi999oNoAb37eNFnLhQhePyQEI13LVRyjJ2ZxdNUJYJth4AEjB37/XPfO9kS7DtdaIskFDtgrknOUdUam/kGEresYszAdBxVmfTpsHxxTXULAcvUMYZXn/ZNB4+tdK18YCkrFKXRUzUy33cW6VkrVJ9cGEZJy7W8MZrRfHb7//U9ZsisAOXQHBfbzoYKxjYNlbs0grZI7eMJ1EUU7gnLIfDVKSHvJFDjqVj7rsmBRsOB/deuwGajisTvjPjBZAysG28KFl1uKScujjS/pB8MF4UN6baOXOilJcsdSnUyx3wmXvcsaHX466FXibK1IRqN+0Hkpwj0RFSHC/J3GOOAQX3U0s1uBl6t1AS+gV7p+VrTcuB7XI8/ze+2NXqz3JEzoZkyOwJVdLcxbVIVapJQSulN/3hPwMADsyI0Y3heQIbGR0nMW1mUCFDpSiSTOfWGuCcI+ks775o7qsN7JoqIceA82vJrZAqcweEYybJw2FdkWWA1uDeazdAw3Z8WWa8KF+fGSvA9BKq4e2mn9XXjx6exf0nl/Hpe07g7ve8Sr4+WTIDskxYwukkWRGbnpkoYnG1VabrZaLM7lHjsCTniHqXA4qbKoZFE7u2HI6z3vWYFHPzC/jNOx4CAPzMR76Ndx95HgDg499+BkBQ4gKQmuXajot8LievlW6tkBNF8fDfUikkrmmglZL6QP2zf3oSwGAcZ73CSDP3puPCdjnGvYRqw3YDRU1J/p7QK5/7+fUGZsYLqXzPVsgtA4gglkTWqYVkmXBnyF67AZqhhCphZkLR3FuYO7llgvujPigIk2UTaw0brsuxHBrUASjBPebYUrD4+Rv3971DpO26MDwLq2nkYLs8E1NOco5oChOgMPcYQqLKedR1Mwko6NE9dGqpjltufwC/+fcPtawSsq7+LC+/RINpsgZ3qm+hY7FtLPnAjqiVEh2zQXRW7RVGOrhXvaVZxZNlAKRyzASskD1wOrguF55vT6IIM7m4pJkdcssASCzr+LKMF9xDzL3XbXAboYQqYdtYwfPqRyRU7VbmDoigH56kNVnKg3NgtWFHyjJmQlnmyNW78KG3XCv3Pcsgl06wHS6rijs9dNohyTkKMHfS3GOkxLrlSAdIGt09Th66GDMnIMvqz3YFOZASXhc+d0qmAkJzX65Zidw37bZ7EFXevcJIyzLk8R4rCOYOiKZdz9k2lujve904bKVuwXY5ZsaLuLDWDOj44aWgurQNu2UAYu7JgnvJzMkqzrAsQ8HsNz77IFbrNqYrJj7w41dnDnJqQJ7xjnmOiSpSYrBxCdVwQG7YrgxUBGr7e3q5DsflrW6ZDkGUXjeNHI4ensX8Mxfxd/MLAeknLeKGblsOlw+borJdpdA+dQKdi//0qXvhcmDPVAnvft3zAudotW7hwIy4rkv5zgnV52wbw/Gza5ED1OOQNlhnWf3RtU7Xe1YrJAV3Anndl2pWYEUZhbjB8gzYVM3HRpu5e6y1UjTkCU3D3CnYFPK5njB3smJKWUb5zHZJM1HE1MrcG4mYu3ALEcONmsZ09PAs/t+XXAYA+NVXH+yKvTYdn7l/8/HzAACXAz/yu1/F3PxCZI+VuOCuSjyEybK4YZ+5IOSEsFum2IG5q0VMgOhLs+rJPFnQzskiXE4iSMVJUklx9PCs/IyP/7uXtpwjlbmTFBH38K9bDqbLJmbGC6lkmbhgPV02e7b6a5LmHmObTYp1ryMkYUsleSFT3EppqmxqWWajYL3RytzT2CGJYU6W8j1h7lQhK62Qyo3eLmlmu65c3hMKeSMZc284KJuiiKNsGrGFTPQgXOuSmTQswdzn5hfwvs8+JF+noOe6buCGdV0uE49htt2wHRTN4CVKuvIJL7hPhmWZFEVM9PecB0f3pUHHh3KoB39Wr7vrcnm9nF6ut/x+1ZvCBHRuCS1WRDnMbqmkkmXiBs5/4M1X40NvuVb+rhuJy3a4cMsYlFDtQpYptTL3JLo7ubXolqP92T1d7jqhOsgOkyMe3H3NnU5uFuY+WTJ74pYh5r4tgrm3S5pZinZLSKO5kx1sqmx2Du6N7i5eYu5xQa9uB4N7oH+PFSHLtGjuXnD3GGdcEVMn5k4PAXo4ZK3ebftQdvyHss/cs3c5JJxeCX5n3XLQdNxWK2Qb5l7KG9i7pZwquB89PItfftVz5c9qED96eBavfv4OHNwxnmlWMYFqOuh42Zl97kFZRjL3hHbIH79uDxhj+OUfe67cn8lSvisr5KA7TI52cG/6neGKeQMTpXyq/jIUICZK+Z743M8HmLsBW+mBEseKbj5ySCRUQ/JEUrfMetOWvbHbLSup2Gm12+DuSSlxQc/lwcZh6uolLDOpBVEEkmWIucdq7h2skPQQmAr1iE+Ldg9lNVfiM/ds15HaAO70cpCg+K0HKLh31tyLZg57twhtOY0kdYPXTfOv/90PtQTxYr77wdyUp8h3y9zr0Zp7eOUex6QvrDfhuBw7Jn19Xm19kQWD7jDZMbgzxj7KGDvLGHtQee0DjLEFxti93n9vUH53C2PsOGPsGGPsSF+2OiGqSnAHkLpK1XKEla1cSCaBdMK5tQZyTLCIcBA6engWv/Lqg/K9KisKNw4DkjP3mlfEBSRk7l3KMiKhasQGPSPHgszdjv43QMw9qH36sox4eLQUMXWQPxpSlmGBv8/K3Ns5WSzXT6gWvO9rZmTuaqA+vRx8cKpTmIDOwV0y9+kymrabqi2H323RbPldyUyW5G8HO1TE1CvN/Z8fWwQAvPfvHpRBvB2TphqI7UrydbKc78otM+gOk0mY+8cAvC7i9d/jnF/v/fd5AGCMXQXgrQCu9v7mTxhj6awBPYTsDOcFt21j6ZqHNb0LrWR2z0gAoblvHSuI4Q0RDPOll28DAPz7H7k8wIqELBORUE3olqEmTJPlPJZjNENqMLbeI1kmLuhtHy/EyjKtwd1pSaiS9CBlmXD7gQSyTMHISYtct8E9XE07M+6Pm3OUXEm3mnuAua8ENXcK7rSqSVKhKpi7qLo8kUKaCZf1qyi2Ge+XFCRB5nKshQikwaoiy8zNL+A3IvI/v/n3D8Uy6bOr4hirzF0toMuCQXeY7BjcOedfB3Ah4efdBOCTnPMG5/xJAMcBvKSL7esKxNwr3klO2zyMJIakgbQTzq01pN8+qrMjySzhG4TYjIqkFarklgEQ6MvS8j6rN7JMwxKFRxT0ZqfLYPBXItvGi4mZe9MLQipMI4dKwUC1Kb6nZLbKVUCbIiY7eCy7De6ACPA/+aK9AIDfU3qPWA6XHSu7dX9QEMqx1oSq2ssd8BOq7Zh70dPcgXSFTLSyUyUPgugj360s41dj53MsU/sBqkynbcziz/eZu1+9O1nKywK6LLj5yCGUYqTXfqAbn/svM8Z+FsA9AN7FOb8IYBbAt5T3nPReawFj7B0A3gEAl112WRebEQ9i7sQgt40Xcc9TyXtOi4Ico2fM/fxaAzMTgmkWZHD3b3a6AMOBKcoKKeyZnbdJZe5tZZlGj2QZxQpJiTYVH/vGUwGfe7v+PVEJVUAwqGrTwVTZbGkl0bG3jOPKZCrQm+AO+CsfNYmp5ko6bVcnEFHZu6USy9xpVWPkWNt5Ab5bRgT3NF53evhPRDF3UzD3NC0+wrBdLh/YhYxDxWnEHq0usvjzz1Jwn1BlGeGsWmvaMrGfBkcPz+LcWgO//Q+PABCEh2oi+oGsCdU/BXAFgOsBPAvgf6b9AM75hznnN3DOb9i+fXvGzWiPatNG2TQke5oZK+BCtRk7yCEMsYRnYpp8T5h7M4K5t/avCXuhRT/3CM09YeOwshLc1xp2ZGFIL9wyrsthOTwyIBMKRi6wf50093BCFfADS7j1ANDZCkmyDKFSENdHt8GdHv7qA0rNlaRp0xz5+d6D/8DMGBZXG4FzGGbugChkimLRrsvRtF2U8gYqBTHIIo1jZq1uI59jkec4TbfSOKgPxLyRjbnTNUyaezt/fnjlR0x6cbWBiWJe3juA79TqRnd/5aHt8v/duIqSIFNw55yf4Zw7nHMXwJ/Bl14WAOxT3rrXe20oWGs4gaTKtvEiOE9uhyK3RtHM9Y65jweDezMJc4+rUO1wE3HOxbASxS0DRFfZETPsRnOn7Y4KyAQzH0qoKu6R6PYDrSkbsi+GnTJAkq6QPOA8YowJF1EfmLs6ZMVvd9yd5n5gZgwuBxYVeVGdwkQomkakFZK+n+SutHZI8o9HMXNK5HYT3NX8kujHk/6z/KZh4njE5X8+8Oar8QuvOCBfU3u1L642sH0yWMlKOY1uvO6UUO92hZwEmYI7Y2y38uNPACAnzR0A3soYKzLGDgA4COA73W1idogpTP5JlYVMCe2QFNxLZjQLSoq5+QW8/ENfwXrTwWe+J4Y9R2nD9B3hwBRXodqJBTZsFy5HgLkD0cyDgkc3mjvd1OEkqIpw61t1RRSVUI2WZYIPq+DnkyslXpYJP3zayVVJQclLlbk7CnNPM9Q8CvTwuGK7aDHwrKe7z80v4A++8hgA4HW//3Vp5RPOldZrlq4xalEggnsKzb3hk4UwJHPv4l6xlPySaeQyuYvUEXuAn/Qm58vWMVMG8Z3KII7ferPfdmNxtRFwygD+yqgbrzvd793WkyRBR82dMfYJAK8EMMMYOwng/QBeyRi7HqLD51MA/j0AcM4fYox9CsDDAGwA7+Sc96adYgasNxyZTASAR54VLT+P/P7XE+ldlhcISh5LzqIlhnvGrNRt3HL7A/g3N+4HELwR/Fas4eAeVaHamblTwB4LBfdwIGvartQ665brBdX0JicKXO1kGdPIxXrb1cBHEk+0LGN6+1No+R1jXnvdmOW8FdnSoAfBPZK5c5TM3iZUD8yMAwDOLNdbri3q0gggNk9Ex75oiirirz96DmsNGzfe+hXcfOR5HWWCNaXNQRi9YO4qkckbLBtzl7KMfw0fPTyL1169E1e97068/eUH5H4+emZVVoufUB5yZ1fruGZ2KvC5UpaJYN1x/YXCoPOftSI6DToGd8752yJe/kib938QwAe72aheQUgS4gTPzS/gz72ezECyntNNT/8rmgY4Dw6iSIq4TP2n7jkhv4NQj3XLRFkhDTguj+z1TpBuIcUtA7QGd2KFOyZKeOZCFeuNjME9gSwT7i0TTKi2WiSjZRlPc4+QZeg72idUgw/KqbKJ5QzzNVVEa+5KQrVHzP2Awtw/8s9Pxlr5pitmZJ6IrrGHFpbxd/OnlEZ19UQ92MOVnyrood7NKlfNL2UdcBLnxa8U8ti3tYxHz6zK1x47s4ar90zi+Nk1WTsBCOa+YyLY596XZaKnmUU1/QsfSzr/gxj6MeIVqo60Qd5257GWoNmpOoyGPXeTKIrL1JM0pN6AtRhZRl2qEpL4pom5h2WZcHCnSt4dnjMgqx7oM/f4B4NpsEDVod/rJejuoOMS9aAgBhWVUKW/iasEtSKqfXshy0S7ZXhr+wHvfKXtMaK2bi7kczizUm9bFNOJuX/hwdOZqiXDPVtU9IS5K50087ngtZIU6xHMnXDljgk8dmZN/vzY2TVcuXMC+7ZWJHNfb9hYbzoBpwzgX3fhwJym8lSVZTjPZqlMipEO7tWGz9yzVIf5CdX2vuF2iMvU04UTNae1VZaJrlClbYyDlGWK7YM7vY8KNrLqgWoXzTgU8tHMfbyYD/aZ8YJzWOKZm1/A//3W0wCAP//nJyODYlvmHiXLlPJ9c8uEmXvDdjP1GKlbonWzkWPYPVXCs8v1tkUxJLFFfQ6AzD3Yw2X9KnrB3NVOmuFrJSkobxT1EDq4cwJPnFuD5YjK3AvrTRzcOYF9WyqypQV53HeEgjt9XliWSRNbyCnmcrQ8EHqN0Q7uTaejHapddRjZ5koyUZT+QovL1P+7H75cfKYSDOoRbhnORf+ZsCwT5ZMPo+pd5GUzmIBsJ8sA2YM77UuahCrt60TJlLNUAf9Yq8GdgiLdXMs1KzIoCkdONCuKS6iu1LtjUhRIGyGfO9lw1eETWXqMVJuOvI52TpZweqWOm48ckm0NCGTli7NC0vWybaw1XwF0rpZcbfRXc2/aboC5Z7FCEnOPeghduXMclsPx1Ll1Kc9cuXMc+7YK1xDnPNLjDvgFdGFZJk1sUe/tfjtmRjq4rynMPcvEIdUtA2Qbkh3XPvQNL9gtv4MQJctQkIqqUA2/N4wwcy95rX/DFydp83QxU4l5WiRh7maIVQeYe4T+rn5W0qDYjrnHyTKOy+X4uCxtWSmhql4jVlTjMNvNtIoUxWgiWO2eKuH0ch1HD8/iJQe2ggGBKuCjh2djHV702k+/9LJMPdj7z9yDUlYmzb0uRuyF9w8Artw5AQB49MyalGdIlmnYLhZXGz5zD1khgegWBNGxJRd5LNX96ffgj5GexFRt2lJzp8TG7975A5xaqqNSMPDff6J9z2lief5Fm42RvOLgDFwO/Nc3Ph//1mPsdAE1I3RmlXWSWyCqQhVo/8CpWn7LY0JUZ0gpy3jBPWsmP4lbRiy1WzX3Ca+0u/Wz/G1PGhQLbXqcWDZvWVmoK5ovP3wmcXJMBckyAc3d9X3uRo4hx4SvP27STzvWTLIMIHT30yt1cM5xZqWBH75yO/7q54NdPsLzAgh0jb3m+Ttx+cy4vB8minn8t6PXtN1H23FRsxyMRzQNA3qnudO1bho5STzSYM1rGhblbLti+zgYEy6Z8+sNTJTy2DFRxD7ZZ6cq+8qErZCAuE7D9wcds3d9+j5ZIPnvf/SKyGOp3u/9tkOOLHNv2i4sh0vmDoiT8I33vBpHr9+DYj6HN71gd5tPoD4k3TF3AHLq+tV7fGsVFZFEth+IYO5R/dzDfx8GyTKqHTQqeehr7kKWIZ9wWjQSuGVEQjVKlgkzd09zVyoIky5/22m14fYDAAJTqrJIJrbjyvOkstZw8Rk92NrJKXFQewTtmiqhabt47OwaHju7hpd5DedUxBUx0fVSMg15P2wdK+Cmw3s62iBpZROXUI3ql5QWluvKYyOskNkqVCdiVhflgoHnbK3gsbOrePSMSKYyxrBvq7iGTlwQfWXyOSZ7wKuYjGmb/ZqrdsJxOf7tKw4gx4A4hU+16GpZJiPCNkAVR67ehYtVC/c83b7PDDF3v4VqNkby0KllAMBVeybla8Qeg+0HWq2QVGYe1c89/N4w5JjBQAl1a/KwGnbL9FmWsV0umy/R9lcKoYQqMXdlv5NKawWDtU2ohiUulblnkUzqEXISEEyoiu0SctHRw7N483V75OtJJhfVLL+NBA07J7noZVe0BvdORUzq6mq6bMYmWFWsSS072g1V7DAkpBMcl4NzBJh7EutoWEZ79MxKoDI9jIM7J3Ds9CoeO7OKK3eKugHZIfNCFWdXRSV5LtfK/CdL+cgKVdLvf+jybbhu3zS+9uhi5HdbAebeXzvkyAb39ZDerOJHrtyOQj6Hf3zoTNvPCFshs2qJDy2sYN/WcqCiMop5E2NUWSct87K5ZbyEakiWiWPuM+NFMJadUTQSyDLSEujJTdKRlI/W4lXmHtdpMhwUC2163VtOxHQnJbhnSbxTQhoIM3c/oRrerj1eMPmFVxxI1GOkpiRUd02J4P7Ze09hvJjHNQppIHQsYlLkrumKiaUEPn+/I2SMLEPj/TLeJ3Td+3NnOzP3KOfRgwsrgeR8GFfuHMcT59ZxsWrh4A6hwZdMA9snijhxsSo87hF6OyCulSiP+rHTIrg/b9cEfvTK7bjv5FLkvFb1uux3IdPIBvcoSYIwVszj4I4x/OU3nmqbNKNA0K2W+NCpZVy9O1jtxhhrSfwR4wnIMm4XskzTQT7H5Cphbn4B33riAh5cWAnsMwX38WIe44V85hYEkrkb8T531TVCf1M0ci1jBxsxn3X08Czufs+r8OStb4wNih2LmGI095W65a0O0rVlVQN6I3TuArKMsl2Uc0lKGGqW392TgvvCUg0vObA1soitlDdgObylSZ5sP6Ds45ZKARfXkzD3+F7ugMLcM94ncgSi0lumU0I1SkZzOXB6Jb6195U7J6RsctBj7gCwb0sZJy7UcDai9QBhopSPTIQeO72KsYKB2ekyfvTK7eAc+Kfj51r3UWvu3WOtjR1qbn4Bj55Zg8N5W58x2bK6Ye6rdQtPna/imtlWdhVmq1FWSJJloipUaRvjQB0hGWOxVXRz8wuoNW0wJm74sWI+c/OwKLYdhhx8rPRiKeRbg3uSz4r/jvigQHkUFZNKz52jh2fx669/nvxdEskkys4KeB0OlfNmKrkACu5JCYNqhfymEjTueepCJDEpyZxOaxtlIMzcC4mY+2qbXu7qZ2btoEq2R3og5nO5jlbIOLms3XFVG6Xd/On75fGjQqbF1UaLDZIwWRJN5sK22WOnV3Fw5wRyOYYX7J1G2czh1z9zfwt5HCRzH1m3TJTeTLjtzmMtPmhKmtFNbDui6Va3mvsjz4rlmppMJYR7slNgcLzZqoZSoRfVFRLo4JZROkK2SxS+/ppdKJviITAecq2kQTOJzz3UkpdkmXCvHJlQbSPxxCH8oFAR1a9mopgHY77///m7xIPYNBjufs+rOn5frUmrDH8fXJfD5Yhl7jQ0JilhqHua+9z8At47508Vol5FQNDNozq81LxglOa+pWJiKaKkPtwrhfYlzudOfeRVOShpzxXAl+r8wi/WsYvm7qkSToWGlxBuvPWulu+bm1/AH971mPz59IrfdmHflgo+d/+z4Jy3FDARJssmbJd7KylxHDjnOHZmFa+9aicA4O/vO4Wm7YJCjOq4ojxejmnmnhl+CXLrhZgkaab2SYljQUlAydSrI3TRcBBSgy8FPzt0wRPCmnuUN1sd1NFun9eV940XW61eSRHlTQ8j3PrWt5uKyVLEiJJ8VhzimqpxziNlmVyOYbLk5yKe9ioVLYcn8llTMJuqmDJ4klasfpe6osjK3JO6eeLmqFIeSU0WbhkroNp05PUdV0H7T16SMI65AwjMPkhbiWuHajoEc29/fF71/B2xv4v6vtvuPNZC0uj47dtahuM9lOOYOz3Y1Htk0at0PbRrQn5HeMFB32HZHEUjh4mSqZl7VrRj7kl8xpbt35z+2LL0zP3BhRXMjBelzVBF2Itct4RGbrscDdtFyTT8pWpEV0ggWM4ellwOzFRQ8RLK7fa5ptjswn7zNEjUfiDUb10dZQj4zdmS9KmJQzHGCkmroLANEQgmmp8573cHrFlOy8MgDEqobqn4rhN6KIcTqtRddDEFc+ecS809qZsnLrjXLadF6qKcw1LVws7J+AfIFx86DSBecwcQmH3Q6UEUZvSHL5sG4EuQSYZ1PHxqBTPjYuD8qaVWBh9ekbc7fuR1B4DtE633KxAc2EHtgh89LYqhDnkFUu2+o+k4MPM5TBSz32dJMbrMvRnP3JNY6qi3iVrElIa5E5P+2++fxGrdiu6BojB3zjnqliuZAQUnmWRqYe6+5h53Ex1fXEfFbD+w4OYjhwIMf6yQz944zHGRY60PIhVmREK1kM+1BP1uZBkzZjyb5cQ/fALB/YIf3OvNzuecAuh0uaC0bW59KJMss9qw/f1MQBjEAwEoFYzEbp5SjC1RjC4MXgfk56YhNnHBiYarx/VzB7wh2d53xn0OkY8wo//ig+LhIat624zZm5tfwIs/+GV8/5klWI6Ldx95HuKuOnU72h2/fVvV4B4vywAIeN1/cFrUsRBzb/cdls1hGp782efOkCMb3GkmaBRzJ0sduSKikmaSOXpL2EI+uhFTFNTlKCBuqKjlqJgWH/S208VD32/HWCFVzT3uJmrarrRBhgcWbBsryH1WR/GNl5IlVKNkIArU7Xrey4SqIssUPc1d3e92XSE7Ic4t43egjA7uKyFZBkjW3IneM1Ux5XmMqk+g4iqSZIBkhEGuQr2HcRKvfzGm8K6hVLoStnitk8kxExecxosGxgpGYDUShsrc4z7HYCySjHzkn0VLbnrQxxUx0f1Fx3G5JvIOcS2g1e1od/y+++R5+dovffx7kYRsMqJ52KNnVjEzXsA27966+cihFlJC30Ey5Lhm7tmx3qaICRDB7l++aC+2VMxIS51cwnsnKc1k98Q9UBTfMy3taYkcZu6tbhk/GMbdRPkcaxlY8KlffBkA4L1vfL7cZ1H9qGjuHS66OC314WdX2iZTAT+hSvtNc1LDRVlJVgFxiKtQbcfcJ8t5RZZZx1avsVY1AXOnB9F02UTTduG6PLI+gc43BaWJYj4RYaBrqVwwEnv941pmRA0dn/aYOzlmbj5yqKXQq2wauGbPVNviICCouccFUiemfJOOi1rE5CgFb4S4+4vz1n4y4Qdf3PEDEEhUn1lpRBKyiYg5qsdOr0rWTt/x3jc+X/6sniPK+XST20qKkdXc1xvB4dhR2FopYKlmSWeKijDLK5nx/UrCSKqLqlZIYjuk6UnmHtM4LJ9jYEzcrDcfORTQ3AFxURfzOdkRkiBZmlKRWG06knWQ5t5u6lTczfW9py/GPkzlPpMso2juk2WzJUHcSLAKiINIXIqgoCYOmzESF0CyjI2VuoWLVQsvu3wbvvnE+VTMnZhjw3Yj6xNMg8GyuXTK7N1aSdQ7pSaL0fw+SZ2KnqTmHmLuokdNSJYZC14TRw/P4suPnMbn7hcyCU0t+9IjZ3B2Ld4/DgjmTquFcM+V6bKJD7z5atx257HI/M/MeBGLaw2liMkveCvmOvcYWq5Z+L2fur6jOyfq+N14612xhEx9rxzYUbcxN78ge/OMFYWTid579PAs3vfZhwL9pAB/Eth4RI+aXmOEmbsTWZ2qYutYAZy3tsAFWpODxXx0OXcU0vRAoQcGMSy6eOh1nwEGTxVjTD4ciI1QGJmuiBmRYK0VupMlEzmGgK9ZLZAZL+bBeXvGGndzVZvRM09V+FZIRXM3FFmGGL2VbRoUED/IxC+yimLuQpahZCoxsTSaO626GrYTWZ9Q8BxBxFD3bikn0tzJalmJ6HIYh7hq0SjmTpr7Us2/JraNiYf983ZNyJXtWj2+ZwtB3Cf+Ph09PCs//ydftBdHD8/GFoq99SX7AKhFTCThBZl7u/srSZFbFJISMiJf33r8HG65/QGZxF1vOAGmH1dkSLLMZMnUskxWVBt2Rxa5xVt6X4gsE/YTqkA65p68B4rP3EmWoYunVZZpZbCqr/qNL9gNugV+6sX7WrR0Qi7HMFU2ZfIMoFmzXkLVu3nb6e5xNxetFtohPJFIau5hF01Em4CkKMYE97DUpmKqbKLpuLJHyPO84J5ElqEH85QXxOqWG1mfYHo9b6gx1a7JUmSLgDCi2kh0QlxCNYq5l0wDJTOHJWU1d3pFBK1nFQ95uylM6meFdX7a/ifOrQMQAf8//osr5e93ThbxobdcKxugqUVMAFrskFkar3VC8kS1gYKRw9cePddWeo3qHQX4LadJc+/nNKaRDe6qdzsOW9sFdzsoh4jJNsmYu2An/sUbq4sqDwwpyyRMqIb/Xl19PH52Dbbjomm70i2jYkulEJBlwlZIAG1197iE0XN3jHVMgNLxlD73GM29YbUO1UgK+jsr4sYS2xAd3AHg/pOiLoGYe1JZxjSY7EDasJ3I+oSip7mfW2tg23gB5UJ0z/WozwfSBvd4n3vUQ3O6XAj0QqHy/eWaJT+jXS93QjFkPHBdLh+QT3rBHQAuU5wpH/m5F+Po4VkpZZlGe+Z+9PAs3vKivQBa+9hnRZp5D5Pl+GQoMX05qD3M3BVZxnF55iZrSTCymnu1aXdM/tByMZq5k8+aZJnoRkxxoCTVF371h/H83a0FTECQudclc88Hvj8uoUp/TyyJWFc+x3D87Jrs5R4lTamNojjnqIZkGaB987Cjh2fx8LPL+PDXhbuBNNnP3ruA8xHHMrzN6n75Pvegu6PRBXMPF0oR6MERzl8AfnB/YGEZW8cK0gpXSyjLlEwjUA8RVZ9ARUxU3l5SfO/tcgu0DVHDJ+IQ1w8pirkD4ppQH/hnlusyOJ1ermP/zJg3HDvakaJ+r8rc6TosmwaeuVCVD/Njp/05prRK9B1G0XNnVVDDr3vf/9pAQ76soAdDkmrayZKJ9YaNWkRgVpl+MVSBDoiWv+VCTt5nq3Ur1UM7DUY2uK83HMmC47BtPOjvVRFugiVaqCZ/yn73qQuYLOVlYUMURPIpmrnLCtWYhCr9fTPE3K/eM4kHFpax5Nnaoi6cLZWCXG7XLeGhLoeDewc98CqvEdoLL5vG7b90IwDgU/ec6OyWCd2wam8ZIGiFzKy5hyQeQlu3jCeHPXxqBYd2TchAmoS5U8BUK5nJ4BHVfmBxTTSmKpoGOPcLt+JA29BpJaoirh9SHHPfovSXcVxRZHXd3il8/5klPKsE97jWA+r3qmyUGvhdtWcS33v6Ip65UMVzd4zj0bOr8j3kbAsTGcozRRUykVul00oiDZIkqgFgomzCzOfwxOJaYFURZvrFiKExlFBVV8jxNbbdYWRlGdFXpf3N0I65hwNBKSVz//aTF/Di/Vsje0ITVOZNSbMWt0zMJCb/7ym4i3140XO2wuXAw88KeSGq4ERtFCX73ptBzb1TJp8eiKoc1LTdjo2+ZELVDhYxtbplnO5lmRbNPT6hSuyvZjl4zraKlKmSBvdyC3NvXXGZHhM+t9rEzHgxUWdPwNf9szD3JJo7IBwzdE7PrTXguBzX7ZsGAJzxpj4J5p5Oc6fW29fOCjLwxKJg7I+eXsX+bUKaoeEw4ZGSYQlPxUrdwkQx39YN1y9MlvKoFAw8d/s4DMZipaFwchmghCqTwb2fAztGmrl3SqiWTAOVghGjuQeXiMUUzP3cWgNPLK7jX92wr+37AlZIi5h70C0jL/iIi7ho+mX6JMvcsH8LPnr3k7jP046jmbu/BJcFMsWg5t6pkIm+Ty3maDpuR2bXork7Qc1d1eK7lWVanAodipgIl22tyO9OklCteYVBKnNXS+gJBW9Qybk1IcsUFV2cHupRqGfQ3KOaeIlti9HcKwV5TmlVd70X3E+v1FG3XDgu75hQDTN3uo6uoeB+bh1N28WT59bx49ftwVPnq74sEyIydJ7odRWrdbvjyrxfmCyZeOTZFVysWnjHj16OX3/d8yLfRzkWFX5CVWx7Px0zHe8exthHGWNnGWMPRvzuXYwxzhib8X5mjLE/YIwdZ4zdzxh7YT82OgnWm3ZHKyRAvazbyDIZmPt3n7wAAHjx/q1t31dUNNdayE5HQV0ywIiAVIzQ3F942RYwBjxwMp65bxkroGY5qFtOy5I/qSxDjD3M3DuxbVVzd10uujQaUe0HsidU4waZdGo/QLhsawW5HEucRK9bbgtzdyIah9H32i6XmjvQuQVBFuYOeNdsRG+ZSObudYbknOO0F9wvnxnHRDGP08t1rHq93DsWMXnMnVwgtO27JkuYGS/iicU1PHluHbbL8UKvlwyx+1bmHlzlqVipWR2JRD8wN7+Arx47i3NrTTgub7sNhQj7tEyoJlwhd4Mkd8/HALwu/CJjbB+A1wJ4Rnn59QAOev+9A8Cfdr+J2VBNwNwBobtfiNLcQ4GgaCZvP/Cdpy6gZObkUjQOvnzAfebeIsu0c8v4zJ9atm6fKGLvljLuP7kEIJrtUbHNUtWSrKmitB8AOgd3knWathsYD1jooJOrmrt6jMMzZaN6oCRFWL8nNJ3WgEtQWeBzto0BENXNiYqMLAfFkOZuRTUOU753ZryYeDZvtemgYOQiH/DtoLqpAJE8b+eWcVyO1YaNM54NcudUETunSji9XJfyQRKfu8v9QC0rxYsGLt8+hicW13HMs5tev2+LeI9MqAbPD13zVgRzX6lbbVc7/QBVZquruT/8yvHYLpdRQ8otb4bvRML7rBt0vFo4518HcCHiV78H4N0A1MfqTQD+igt8C8A0Y6z9FOo+oGmLwNFJcwcEc28ny9ANKRoitb8Jqd/KX9z9FFwOfP6BZ9u+X3WI+LIMBfcQm4l1y4jtXKlZmCwJDfK528elXBKVhFMbRdVk98y83CbTYB0Zhdr/m5JbxEraQW0cpjqSWrtFtnYvTAr1oamiXRHT3993ShaB/con5jE3v4CyachcSDs02rhlzFwrcwfEQziuRUAY9Yh+MEkQbpkhj3eMWwYAltYtnF6pI59jmBkrYtdkCadX6m2H36gIP7Bk6+1CHldsH8MT59bx6OlVGDmGK3eNo5DPRSRUPeYufe5RzN2WEuagkHZ4utrdlNDK3PvXPCzT3cMYuwnAAuf8vtCvZgGcUH4+6b02UHzme2IT/ueXHo0doUfYOhYT3MMJVdNoOz4s3CysGdMsTIXKMOuWmLdJwZgCkyN1yA7MvdqU9svn7vBHh0UnVKncvBnZGnk8wTQmteCFOuQ1kiRUvf1o2K7S1jfCLWO7geHYaeBbIYM3YpwsQ+eOQggNcLAcN4UsE9TcfTktaIUkbJ8oxnrRw6g2OxfkRSHs8KKHSJxbBhDXxJnlOnZOlpDLMeyaKuHMis/ck2jugL8CUxv4XT4zjgvrTXznqQvYv62CYt4IXGtWSIIMN5lTsdoYPHNPOzxdbcVAkI3DBpBQTX33MMYqAP4LgPd188WMsXcwxu5hjN2zuBg9KTwL5uYX8Jt//7D8udOAgI6au2TuOdkUKgppn+r0mYA44TXLQSkisRjVOpagMvelmiWDthrc46yQgCfLNFsZfpJpTMveSkH8W7y3aTsdmTtjItFnOW4grxGZUM3K3DtYIcO20rhzJx5+yWSZkmkoCVJXKcgJNg4jBGWZ9sy9ZrmpbJCEkhnU3GUb5Ri3DCCC++mVOnZ6A6J3TZZwdrUhcyudi5iCDyy6vsaLeVy+Xchd333qgiwSqxQM6ZaxQ8csr0h4YazUOtsye420w9OjZRnR8tc0BBkYqiwTgSsAHABwH2PsKQB7AXyfMbYLwAIA1SKy13utBZzzD3POb+Cc37B9+/YMmxGN2+481nJA2wXZbeMFrDedFvZkUVdCpXEYEG3LAtI/1QGlba/lyjFqtBSVrWNdweijilzUCrilqiWTggHmHpFUjpJlygozHC92nhKzVG1KbVrKMgkLj0wjB8sOBfeQw6UnmnuMLGOGtjHuHFkOT2mF9L3lcsWlWiGpT3k+h8lSPvFs3lrTjkyCdoJYbSrB3WPupYhzNK088E8v1+UQ7p1TJTgux1Nez52OPvdQ7sR3Yxm4fLu4Ljn3i5BU5h5ukxwepk7gnGO1bg3cLZOmihVonQhG4zOpdma8aGYeRp8EqYM75/wBzvkOzvl+zvl+COnlhZzz0wDuAPCznmvmpQCWOeftheceI22QDQ8qINBwbEKnGzHtUx0INriqeY2ycjmf2QJCb4xre6v2g1+uWfIGPXbaLxB5zf/6WsuqRU2o0s2n5ifElJh4LdB1OZZrliwhX6lbMlmXxOFClZpS+jIMWa7t97fP7nOPc8v43xf83HbMK6oKMQzJ3BVJggKSmlCl328fL4IxloK5d26lEYWwLNOWuSv3gWDuIrjv8v5//Kzwp6dm7g0b+RxDwcjh+0/7qbv/882nMDe/IJi71NyDq1SStMK9Zdabokhs0LJM0nbLhLDmLleOeX8W7VB97oyxTwB4JYAZxthJAO/nnH8k5u2fB/AGAMcBVAH8mx5tZ2IkGaGnYqu3HL2w3sTuKf894UDV6UaMa7vbrpmROi2+YblSs1XbEohlXHSQCzL3JqbKeczNL+C/fe4R+Z5TS/WWAcol00DZNLBUbYJ77EeVb8aKhhwDF4XVhg2XA5d5RSjLNQu2y8F5sslJYlISb+286e0357wnPveoZJb6e0LcuTu4Y0y2220Hce4M2amzYTktzg/13zNeawO/uVdnt0yWSsxi3ghYVettmDut+k5cqKHadGRQ3z1FwV0Qhs6Nw1qZe6Vg4LP3nsJ/VfqlX6hauOX2B3DZ1rKs5rUc12tlHbRChlfLtFIchhUyaRUr0Np+IEwuRE/3ISZUOedv45zv5pybnPO94cDuMfhz3r855/ydnPMrOOfXcs7v6deGx+HmI4damG67ICsZy3rwIFshiaHTjUhPdfruJM2MfOYu/OYUYE0laNuuG5lMBXxNj5j0dLmQWPunQqZq04HhMSvCeMmUOmgUlr1kqmTuNSvR/FR1uy3HbRmCTQ8r2xtS3Em/j4OfnG2V2owca6lqjGNkV+yY6CjLOK5w/dD1Qd1D7YhEeEFh7oDKcjswd284dlqUQvbddszdyDFMlvI4dmYFAHxZxgvyjy+uwzRYR6ksirmPFfOx1+XTF9QiJt7SRRNodctQAn9YRUxJEZZlwvdIv6cxjVyF6tHDs/jEd57Gd5+6CM7RtgEQ4PeXOb8eZKqtskznG/Gm6/fgvX/3AH7mxfvw/h+/uuO2qsv4uuXIHtwFw58kZDk8smkYIC4S2+VYrQsmPV0xE8tS1IJgvChKqVVNv9OUGOr7vWOiiJKZw7Ia3BMEZJKdKNjQ31Bwpxui11ZIKpiKQhQj+85TFzo2DpPVo17AJPthlBXy20+cBwB8+ZEzuPHWu/DOH7sCQGefu/rgT4NwEVM75g6I4rZHnhUMnZj7trECTINhrWHLQS9tvzOGuT+xuB75/rrlSmnQctzA8YpLqNK1OWhZJi3C7QfCXUknSvnAvN5eY+SCOwCYhoEX7J3G3Dtv7Phen7mHNHcnLMv4Nrc4rNRsrDcdzLbR2VUUQsGdqv9UucV23MimYYD/wDm7KopOpspmYllK9BKxsG2sVc8V05jil4tkg5yumJgsmVip2Yp1tHMQkpp7FHN3VItktoRqXE8S8cBO3otE+NyTBXeS7cLM3fC+b25+AX/2T0/Kv1tYquG3Pvew9xmdmXtazX1ufgFffOg0qk0HN956F24+ckj6wqOYOyAe+E97iVNi7rkcw46JEhaWah0lGUCVGr02wR5zj7suxwqGZK+2wwPJbmmFDDnUhinLpEHRG85CCBOgJK60bpCNGm1wLCzVMLslWYCdrhTAmNAAVYQLcuIaMYW/F2ifRFWhJv5qShfEgpFDgxKqoaWqCgqKZ7ze29OVQuKM/nSlgIvVJtYjPNRjhXyg+VUYVMA0VS544+msVAOtTSOHps2VIB60m0pGn7VxWFxvGSddS4NKwfBmc8YPVKjJ4O7vQ91yWpKDUS4uupY6u2WiWwbEIVxJSXbgrz+6GNjWMFRmTnIM4Af6Tu1+1c/2mbuYzxt3Xb70im3Sbmq7brBFcsywjs0iyxTzYgasLVfhQbfWRJ9lmZEL7q7LRXBPGGCNHMN02Wxh7lYoEPgSSvyNSNJH0u9WZZmGsvQu5HNy0ER4qRr198Tcpytm4oz+loqJpaoVqeeOy+Zh0fu67DmLpiumGE9Xt2TBUKKEaj7kllGYuzgW8cU2ScAYC0hbBMvuXEGromQacHl7N4uUOsLMPZRQbWeJ7bVbJk7f/uy9pwDEr4hoFTtdMQMPE5JoOrUeABBohgaIa2i8mI+9Ll942RZYDkfDdtC0g+YBfyRjnCyzsZl7y9B3r0dOgLnX+zeNaWMfnQw4v95E03YTB1hAaI3hKtVGSHNPwtxPLadj7uR3FczdkVooyROASNh1Yu5nvZmc5HhIktGn/t1i2Ry82R+j3h+/9Y+ROQuSZabKJqbKJs6s1FuSo+33O1jEREGcXELhoJ8FkVNwvL4eSVFWAlUccw7LMlJzd10w5lsh42QJhvbMnRLMaRKqcQ8S6gQax9zJIrtLYe2Az+KTyDKlfBRzjx/s/Rd3C6lqveG0mAeIxYdzJ74ss/GZOyDO4VhRrXoX+zVeNGF705j6MbBj5Jh7WmkEALZG9JcJdzhMUnCycLGGQj6Hbd74vk4oKjp+XXXLhKyQRifmTrJMimXqdKUAl4sHg1rANDe/gNu/fxKAaBoUVeG7VLMwXszDNEQxzko9nVumreYeYO7ZL3iaV6rCctIxd2LL7dr+hhOqvubOAyuuOFlivNg6c1RFVJFZJ8Rd+1Okuccc1+myuG53hoL7binLZGDuHQbVqzN7wzUdcZOYVuo2Smauq4f/IEDHomGHZBmFuQOQHTd7jY19dDJg4WI6aQQQzD1cxNRqhexccLKwVMOeqVLbAR0q1DL5msIOVUnBdtslVD3N3ZNl0miQpK8uLNXkoA5ALOnDlZ1hK6VaDTtVNrFctXyHSyK3jOdzD/l+C3kDDcdNJfHEoZBvlWXCy/5OoIdtOztkLY65e7ZLQpwsMT1WaNvytxZ6eCRB3IPkRw5u97Y1+hg8c0E4Wr726GKgJ9MzF0WS9Y77TnXs1RRuY9xpUD31Plpv2rLXOcHIMeRYhBWyNvi+MlkQlnLDCdXJPveXGTlZRureCROqgLB73XdiKfBa03ExrVohExSc0OzFpFBLteteIQwgAlO16jsI2lWoAsDiSgNl00iVdCN9tWm7qCjMKomVUjQpEzfXZFmUUNNxSWJfjGo/IPYnyNyHLcvQ8WznmCGZLszcLadVTouSJf7oq8fbzgmoRvT+6QT6jg9+/hEsrjawdayA973pKs8J82wkc5+bX8Ad952SP9OK7Z6nL+BT95xseV39HhV5Iwcjx2T9RdVy2nZnJVYvZJnWh28+IncyzEEdadCiuYcSqklnJ2TF6DH3pRrGi/lUyRZi7mpiI+yW8dvzttHcl+qpVgz0+VSlRozKVBqCWY4b28e7oDD36QQeZBXq+9XAkaSNgtqkbKpsgnO/fQPlEdqhkCefe1RC1fFXAV0Ed1NxHBGslJ0mK6mYe9AtI1Zcnb+r02xeydxTarJHD8/iH37lFQCAX3vNQRw9PIu67cA0Wou4ALFiC2vbNcvBJ759ouUhmaQhXt1yULcdcO5P+YrCuCLLiGs9uG1iFdtaxLTRbZCAHzOkxBq2QiYYRt8NRi64n7wonDLtpsmHsbVSgOXwQBMfy+GRPvc45m45Ls6s1lMxd2I5VCJORUzFvCrL8I6yzNmVRuoJ8MTcAQSWzTcfOdQSVMNWyqVqU+qztDxe9JK6ia2QquZOnTeNUBFTF5q72sKBIAYlpPO5A52Ye0iWMQ05iSluxaWi04SvWsYpTACwbayIHPNzMu2Gjset2JwYJ0c79w+tXtZkL/f4badrr0qyTC7M3FnLmL1NK8uEjAKkua/o4J4Mp1J43AlbxloLmcIJ1YKRA2OIHdhxerkOztNp/fS51DJXtULShWA7btsKVUAwqW6Cuxo4jh6exW+86fny5ygr5XLNwpQiywDpg7vluWLEcfW7JfbC5w4EH5CEppOMTROSaO6NCM29YTttewIFtrPDhK/wGMQ0MHIMM+NFaZWt2/FDP+JIiRFDktqRGGLu1Mu93Wg+X5oQVb1h5m6OgixjRSdUv/W4qFj+xf/7vY65jCwYueC+sFTDnulS5zcqIHfLeSW4h62QsilUjCyTxaUDiAtAMncpy7CAW6ZThSqA1LLMRCkPIpZhN8NPvkh0bb75yCHc/Z5XBQI75xxLVUs6c6jqMT1z560PUO+h1gtZJlJzT+lzDzN3mrR14D3/IG/GsCxTMg00vAKwKPkjjFK+vVuGnDpZWv4CwI7JorTKtmPucUnYt/3QvlRtbmlbG7arzAqID+4VqbnbsCI0dzPHNrEsE/a5+8x9bn4Bt/2jL211mjuRBSMV3NcaNpZrFmanK6n+Lpq5Oy3BJTz8QMUpGdzTPViKSnAvKwlVOSDb7czcAd/GlhS5HJMtgsM2u2JeyEVRgyrWmyLxpWruAHBurSn/thMKSm+ZsN20abf637PAjJVlsjF3ddKWahGdf2YJgFrE5ElOEfpxFDox93oXzB0Adk6UpCxTbzO6MM7N89tHr03V5hZQmDu1k25jhZSae9OObLVhRqzAVmr2JpFlgnk6f4Yvw213Hms5751yGWmx8R9/KZDFKQMIzR1AwOse1twBumijb8RTXTB3KsooSiuk3wc6aqmqbg8hLXMHhC/+wnozYIUExCpFnZCjggZjd6u5k89dZdKyQrUXmns+1zIqkGSgpKiYpAc7+KO7jkdWff7TY+eQzzHJOGmb1xtObGWxinBzrzCqzWwJVcKOySLuO7kMoD1zB+KL39K0uQX8wdz+8PX4MENEQiZUw5p7jgWskHXLQdNxBz4/NQuKoX5UlFAtGkam4T5pMVLM3fe4p2PP33hc9Ny4+TP3y+V2M4JFiOVm9I24sFTHzHgh9fI5irmbeV+WibKHEdRAOpUluHt/E8Ws4uaoyupUYu4VYu5ecE8QPMmD3prXMOC4XPZQz9oVkrajZcSZHd8VMgqlgp9Ej7vp1hp2QLYgeWa9YSdk7kZbB5YcYG5mC2bbJ0o4v96A7a2UsgzaTos0zF0lEnGau9p8i/rKbPTqVKC1x5FvhWSZhvukxUgF95Oyt0tyWSZ65ur9gXFYBMGy4jX3LCemkDckc5dJOe+C5px7CdUEzD2lLAP4SdWo6sdKwYiszKQHEWnu44W813iNrJBJmTv3RukFmTsA6VrK2s8d8Hrih62QKd0yBSOHHBMBNu7cVgpGoMsiMeM1bwJRJ1AgjIPU9AvZjsWOiSI4F/kkwdz7f8uXQsw9aki7CiISltu6sjKNXKBx2Eptc/SVAXxyErZCmkYu9ci+LBip4H5qqQbTYNjhTbpJAtFkKax9RRfRRE0zV797z1SW4J6Tg4FVzR0Q0pCVoLcMkF6WmZtfwDe8bP27PnVvSyJnLKZjnd/uVzwYcjmGyZLwuheMXKLqXNru9abTklAFhO/XNFjiSt8oFCM093CP/k4QrDKPatOJvRmv2j2BshJ4iRmvNezY+gQVpQ7Mvdq0W4appAHdC6L/T7rukllBDyxflmn/nUQkopi7sEL6sszqJukICURp7qLfUD7HUo/sy4KN//hLgYWLNexKUf4PJBtgDYhg+INnV9F0XNkfm04E5xynlmqyvDsNoqY9qePF2lohlRs+jRWSkoPECs+tNVuqDscK+ciEKg3qUB8mk+U8lmtWYusiyV3rDTuyf89q3e5Kbwdi2g+kbPkLiOBbsxx5XP7zp++D7XJsqZh4/49fjS8+eFpaWcU++O6PRD53UzyEXJdHXre1pouyaaSq21Cxw+sTc3algfoAmXvTdrHe7GyFBPyJRKKqt5W5qw/plU0yqAOI9rmbivU3bS4jLUaOuaf1mbcdYK0MWrjl9gfkMj9sW1quiXF1aRO5QDC4tzB3r3VsHHOnodJAuuCeZBTfWDEuoep3hCTQv5MHd1+XDidUAaGrdtsUKsoKmbZxGOD1dPceckcPz8p9ffvLD8iqTzXZ6WvuTjKfe4fK55pld9UxkJj72dUGGrbT9UMzCcgyTKuOTg+USiEvE6pmLqy5B5k7SZibQZaRmjv53G2eqkK6W2z8IxSDufkF3HbnMdnP5eYjh7CwVMPLrtiW6nOihiPTxUkBJi4Y/trf3IsP3PEQXK+K74+/+hi2jRXSOQtU5hoK7k3HhdWhjJ3sg2lkmSSZ+koMc1+uWSiZucDynlhU0sBJ+7PWsLFdkdCKiizTLcMMMz7bceHy1uHYnVD2mDt9BuUWFpZEMy11PKLYB6/kPKEVUp3wFRXEs0xhUjEzTsG97vUvGlxCdb3htIxwjMJYMY+FpZpYpUYwd3Xko+zlvglkmZwnpxEpbDpOKitu198/sG/qIaI8x7/2N/fi2eU6vvTQmVSFAKR9UVHEnqkS/vNrRVKDgmw76WapZsml4oV1K3UhQlSLAynLEHNvs7ynIDhdSZ5QTZKpF5p7tBUynLxNy9wLCnMPJFRlrx27J8xdLX6hf6eWZQqGzMFcrFqgavyTnjOrZrkBV48aPJPJMu3nBFQzDscmFPI5bB0rDJS5Ux6h2rQ7JlMBYLxoxBYx5XPB8yinMG0CWQYIzlG17PiCxH5gUwb3KCZNWG3YqQOsKLm/CgDwyXe8DD96SGjndKGlccGkLUSgmy3HlB4rSmWbGLPXjrkbyOdY2/4dYSTJ1I8VjGjNvWq1rBLoRkvKtsmxst4IFTGZFNytrpk7MSZqBidtaGllGdOXZcjuWcznZHBvWMHgqwbPuFyJik5zArIOx1axY6IoNfeBMvemE+g4GodKUawSI4uYvII3wkrNQj7HBrIfvQA1wwOy5Xy6weY4QiF0MvpnqfSiAQVnVustDa2igmE326eCvqOkJM3oNbrhwzokYW5+AadX6rBdjlf8zlcTP9CSZOrFDefADQ0nVjtCEsjrnlZzDxcVkfW0VwlV+g5A7aWdjjmVC74sc96rwr12dgrPLteEJz80pSnA3BPJMvGa+9z8Ar79xAXMP7PUVe+RHZMlLK7WB8rcbZdjpWYlZO55rNRtuLz1gdhihaxbmCybmRPMgwbJpkD63kbdYlNq7nEjy1SkrfSi0WKnl+syMUoBgoLebXce6/i9tH1JQd+hPjzUhCOASOZO0pTjBd9OfbbD6JSpH/cYV9VyAhN4lqsWDsyMBd5Lya20wT38N9IK2eyBLKNIW8W8Idlf2s8tm4YsJCLmft2+adzz9EVPx45n7klb/gKtzD0uiQ8kO78qdkwU8fCpFbg8flBHL0GrkYvVZqLgXin4FdlRVkhVllmt25simUpQi9TSzvDtFpuSuSdh0mkLinZO+n7gqJFxRw/P4u73vAq//1PXt/3utIUIdCOo7I++t0rMPYIBJnG8dAPZilXxus/NL+Cxs6v44kOnA0xSau4JL9woh4z6b8676yujfhYFhnBHvqQoF6KDOyB091ozWPWp/jtJ47A4t0wvz++OiaIiKQ2GuQPAhbVmotF86nvC13p40PlKzdoU1amE4kaWZRhjH2WMnWWMPai89t8YY/czxu5ljP0jY2yP9zpjjP0BY+y49/sX9mOjVVkBEEOGVWSp9Joqmyjmc8HgHhEIwpLGdNnEloqZuRChIIN7a5CjoBKVmOt3bwo5IUfpiHjL7feDVBrVDkrOhWJC6cqMkGLEv1s971khZZlQR75u3DLn15swDYardk8CEHUVddtFqRDH3JO7ZcLMvZfnVy3qGyRzP7/ebDuog6D2nmmdxBSyQtbtTdFXhkD9kgC0jBHsN5IcpY8B+CMAf6W8dhvn/DcAgDH2KwDeB+AXAbwewEHvvx8C8Kfe/3sOVVaIskWmXboyxrBzsoTTK42OS/heFh9QMCi1kWWMiAsiTprqVW8KuuFoG6IreQWT/O2j1wBIY4X0g15UQjX8ehaojiOgdVBCUqhtGM6tNrBtrIi9nmz3zIUqmrYbtEIG3DLJfe7h4N7L87tDGXg9SObesN1EiX6190yUFdJSVjWrdQs7JsZ7tKX9R0BzH7As0zG4c86/zhjbH3ptRflxDAA9Wm8C8FdcWBS+xRibZozt5pw/26sNjkKvgu2uyVKsLNMvRGnuxHwoqEQlVKP8+b3sTaGOPwPaM0nJ3BO7ZaIZetRYw6wIJ1SlFTLlzUW2PtflOL/exMyEaA43M17E44trAIIdG9X9SedzDz44bz5yCO/+2/sDXv2s51dl7t00Y0sK9Ri06whJCMgyLUVMOViuKsvYm6KXO6GY91d+TYcHWlX0G5m/iTH2QcbYCQA/DcHcAWAWwAnlbSe916L+/h2MsXsYY/csLi5m3YyeYueUF9wz6rNZ0FZzJ1kmgTzU694UVDhD29DOGz9VTpdQjdPco5qIZUUhzNwzPrApcNdtB+fWBHMHgL1byjh+VgT3kvKZNNQFSHb9xDH3o4dncdP1e8Rnorvzu2NiOMwdaN8RkqA+AFqZO2vxuW8WjzsQtEIOOqGa+RHIOX8vgPcyxm4B8MsA3p/y7z8M4MMAcMMNN0QPahwwdk4UvQZL8Zp7r1GICO4UFMhnHqfd9rM3xVhoMns7JvmNx88BAP5ufgHfefJCR1nMjNHW4wJ9FhQ8L73P3DP63JWH3Pm1Jg7umAAggvuXHzkDoHVKErH9RAlV0twjrJBTJRMlM4eHf/N1XTVR2zE5HM0dyMDcw26ZXA6Oy+G6HC7nqDadTVGdSlCLmERCdXMVMX0cwL/0/r0AYJ/yu73ea5sCu6ZKqFtuoFil32iXUKXeLkm0216DgntV6avy0z8kTq3KJAHgv3/+B/LvkowLi3LIhP/dtSxjBCfP+wnVdDcXBe5a08HiWgMz46I6d3ZLWVaVhouMJHNPUaEaNZv38cU17N821lVgp+8gKWMgvWWUazkRcy+2Ehv/Z7Hvluvib74rRIH/9aVH+zJztB8oKq2nB51QzfRNjLGDyo83AaC7+w4AP+u5Zl4KYLnfensvQYmnExeEvjw0Wcb73ppFPvfBF2xQIkxtHnZop3CJ3P2eV8nZqlnGhQUSqgHnTA9lGWmF7C6hSrmQs6sNNG0X27zgvneLPzMgHDDpXCZq+dumcdgT59ZxxY7eJA+pSG8wzN0/HmmZe9gZRvfg3PcX8FufC89d6O3M0X6gmDd85r7RfO6MsU8A+CaAQ4yxk4yxXwBwK2PsQcbY/QBeC+BXvbd/HsATAI4D+DMAv9Sfze4PqJDp5EXRFGoQCVUK7uWI4E6BdZD9KAhhtwwgeqsAwXa/WSx7cUE8b+SklNFrK6R0QGWUZeiaoEZce5UOoHHMPclD2TQYGGvV3Bu2gxMXqrgiVDCWFZRUHYzm7h/j8USaezxzpwfk73/lsZYHYK9njvYDAc095QzfbpHELfO2iJc/EvNeDuCd3W7UsECFTCcuDDK4+4OVCX5C1WPuQ5BlCvkcCkZO+twB0cu9kM8FHkRZLHtxFaqACL41N36Qc1LQAzE8eT6Lzx3wG4Vto+Cu7F8ptA+SuSeQUxhjKOVbB3Y8c74KlwOXb++euc/NL8hB3m//i+/gv7zh+X3tI56WuY8FEqrhIibx8+nleuTf9nLmaD8wTCvk4KPGBgYtXReWanJiSr8RZYVsdcsMp49GpRhsHrZctTAd6uuRZVyYyl7CFzvte7c3QTEky2RtP0AFSvTAVzV3QixzT/hQLpmto/bIZnn59u6Ye3gwy9nVRt/ljLSaey7HJHtvGZDtXQdbx6K7nvZy5mg/IKa3qQlVHdyHgpJpYLpiwnJ4YGJKP0GBQK3uNHIMOab43Af4tFcxVgiO2ovqCJnFkhlXxKT+nLTaNQ5fOybstf/hE/O48da78N2nLnrfnU2WORGSZSqFPLZ5ASfKLSO+K9n1o+qyhMcX1wF0z9z73aYiCurxSMLc1fepbpK5+QX8zhdFOu/CerPlb3o9c7QfKBiiiZrtuF5cGRxR2zzVAAPCzokSlqrWwCamkI3wtjuP4a+//Yy0ERbyOcmak1jq+oGxooFqIyjLRA3iTmvJNHPxsox82HVx/KlimbCwVMNn7xVMNe2KICzLEIOcm1+QvcV/5iPfxi2v96UOX3NPwdxDs3mfWFzHzsliot4s7dDvNhVRUPMlSRqHAUKbP7fmM/fwioNDtMWeKptYqlqZK9EHDVrF1CwHjssD7Tb6DR3cQ9g5VcKxM6sDWT7NzS/gj7/6uPxZ7fxXMHJKhepwmHulkMd6M8jc922ttPmLZMjlGPI50TMknDj1mXv2fb7tzmMtvvGswzpIclm4WMN0xYRp5GTgoc88s9IIdGxMo7kDgrmHZZknzq3h8pnu9fZ+t6mIQsHIgTHRAC5JP3fAZ+4kQUatOFwu3jf/vtf2doP7CLq+pTlik/ncRwo7PVfBIKSQ2+48FusAEMx9uJr7mDchh7Dkae69AB3fsHsjPLAkC9qx0rTLYmLutsulJNNJ6kjjlgEEc1evA845Hj+71rXeDmTLiXQLtUo3OXMX76PrYhgrjn6Aru+1hljl6YTqELFrSiRVB8Hc213ABSMnA+swrJCAuDGrIbfMlpjEVlrQPsXJMt0c/3asNK3EpQZG0tg7BZ6iGZ0cjEPRDDL38+tNrNTtnjhl+t2mIg4l00COJffVU+KVVjtJRkFuBvhD3+3Az4OAlmVCoEKmQZyEdktm02CSzQ3DCgmIKlWSZeqWg7rlyt7t3SLOFSNlmS782FFN1fI5Bs556iR53sjJkX0z3qquk9Th95ZJKssEh0A/4SVTr+gBcwf626YiDsV8DmOFfOLjXQkx9343xhsU1KHvwGDNEZq5h0CFTINYPrVbMqsXwdCskAVDaoXLtdYCpm5A+9fK3A3v/9mPP7FVqrKdnS7hxiu2JXZuhEHsc8Zj7p2kjlJK5k69aAhPeDbIK3rA3IeFYt5IrLcDwHghGNyHteLoNWRw91bhWpYZIqiQaRCVZO0uYDXoDcsKOV7MS2loiapTI9wyWRAX3As9kGUAcWwp2M698xXYt62S+ZxSUpU0906BJ73mbsjeMnPzC/jtfxBl9j/14W9u+PL6KMzNL+DUUg1nVhqJesDMzS/gcw+cAgAc/ZO75ftp+tmTt75RtrvYbCCJTjJ3LcsMD/c+I/zQ950QQ4n7bbeKWzIHyvKHZIWsFPJo2C5sx8XFqvAZ9465R2vuhZhEaxYc8JjvE4trsGyemTUJxt+Q1alAe6kjLXMvetN6wva/U0v1zHNThwXaBzvhbN/wPp9e3nz73A50za1q5j5czM0v4ENfSNfhsF8IyjLD0tz9UXvE3HuluUvmHleh2gOGc7nXl+XJc+teX49sD0kK1lSd2vn96d0ydc9tM+iCo14j7T6Mwj63A1l612RCVVshh4J2o+QGjWJAlhmWFdJv+7tcE8y9V26ZYseEaveX5p7pMgr5HJ44t45GF+1WqUpVZe5xmJtfwP/+8mMAgF/+6+8nIgYlz+c+Cva/tPswCvvcDr7mLsiRTqgOCRvpQlOD3rAqVCtK219fc+8dczcNFuhVPje/gM8/IDpEv+VPv9H1isnIMezfVsETi+uZp+DMzS/gwYVlAMAvffx7bbeJJIYlL/l8bq2ZaOVH/UdGwf6Xdh9GYZ/bgYI7uaG0LDMkbKQLTX3CD6tCdUxp+7tUs2AaLNCetRuYnsWQQIGRfPWkvXYb4C+fGccT59ZgZWjaRNtEThaqRI3bpqwSQykv+o+8618cbFmlbTb7X9qiqWEUWQ0SlDsizX2QCVUd3BVspAuNAlGOoetJPFlBssx608ZS1cJUudCTZmpz8wv4/jMXsd50pJuiX9rrge1jeOZ8FdWmk3pJnHabsq78SJd97TW7ccP+LWDofm7qsJDWwjgqlsc4+O0HBs/ctVtGAV1Qt915DKeWakNtTlSQdrrhPX8poVptOFiqNnvilAmzYUpah4MooVtJ7PKZMdguxxPn1vHclL7xtME6ax8XddRetenihy7fik++42WptnUjIW3R1DCKrAYFydx1herwsVEuNGKZSeZw9gtyGpPH3Lf0ILjHsWGDMTi8dU56t5IY9WdZXG3g+bsnU/1t2mCdtaqSRu1Vmw5+8OwK/vVLn5NqOzU2Lgq6QlUjjLRtY/sBaua03nCwVBOyTLeIY70O532RxA4onRXTLonTynRZJQaSZR46tYKG7eLqPekeQhobF4Vwhapm7hp0EQzLBgn47VqrTRvL1WZPgk4cG571JLBeS2JbxwqYroge4Gk9xllkuiwrP1q6f98roLt6z1Sqv9fYuDByDKbBsFonK6Qe1nHJgy6CYTUNA4AKlU57bple2CDbSRf9ksQOzIxh/pmlTEviQch0VPT0/acvopjP9axhmMbGQMHISeZeHOCwDi3LbFDQxJZhNQ0T351DycxhqWqh2nR6klAdhjuChl4M0qmQBsTc719YxvN2TQxVitPoPYqmAa8bw0CHdWjmvkHhyzLDvdHHCnkpo0xVelOdOuikNSVVB+kxTgNi7k3bxVVabx85BKvNdUL1kgfJMsOqTiVUioZMgvbCLTMMnFutAwD++tvPJOpSOGioA6Wv0nr7yIGCO2ODbQKog/sGhXTLDDm4q8y9V+1+B4m5+QX89XdOyJ+H2QwuDiqz006Z0YO6Cu9FEWBSdAzujLGPMsbOMsYeVF67jTH2A8bY/Yyxv2OMTSu/u4UxdpwxdowxdqRP2z3y2DCyTDHv95XZhMy93ZzajYKvPboo//3LH0/WbExj80AOoBnwvZzk2z4G4HWh174E4BrO+QsAPArgFgBgjF0F4K0Arvb+5k8YY4NLD48QKKgPM6EKINBLplftfgeJjdQMLgpz8wv4nS/6baZP9ainjsbGgRy7OOCcT8dv45x/HcCF0Gv/yDmnoY/fArDX+/dNAD7JOW9wzp8EcBzAS3q4vZcMJHMfohUS8AuZgM3J3DdSM7go3HbnMdQ3SJtpjf6AitQGXbPSi8jx8wC+4P17FsAJ5XcnvddawBh7B2PsHsbYPYuLi1FvuaRR2DDMXQT3fI4FAv1mwUZqBheFjb6y0OgedC8PsjoV6DK4M8beC8AG8PG0f8s5/zDn/AbO+Q3bt2/vZjNGEuYGaD8A+M3DpivmQJNBvcJG7zq40VcWGt2DNPdB588yUzHG2NsBvAnAqzmXHZ8WAOxT3rbXe00jJYoboHEY4Lf93Yx6O2GjNIOLQtZmYxqbByTLDLqILtO3McZeB+DdAN7MOa8qv7oDwFsZY0XG2AEABwF8p/vNvPTgt/wdthWSmPvms0FuBmz0lYVG9xiWLNORuTPGPgHglQBmGGMnAbwfwh1TBPAlb6n+Lc75L3LOH2KMfQrAwxByzTs559GNujXawnfLDFeWIc29V+P1NFqxkVcWGt3DT6husODOOX9bxMsfafP+DwL4YDcbpaG6ZYYtywjmPrUJnTIaGhsBpLlvCllGo/+g4G4M2QpJmvtmrE7V0NgI2LA+d43hgJ7yw+znDgD3n1gCAHz07ic3ZF8WDY2NDiJqmrlrANgYCdW5+QV87JtPy583Yl8WDY2NDinLDLDdL6CD+4aFLGIaoixz253H0NzgfVk0NDY6ipq5a6i486HTAICPfeOpockhunpSQ6N7DKsJoA7uGxBz8wv4wN8/JH8elhyiqyc1NLqHTqhqSGyUZlIbvS+LhsZmQNEcjhVy83WCugSwUeQQKqy57c5jOLVUw57pshxkraGhkQxSc99oFaoag8ee6bKcfhR+fdDQ1ZMaGt1BWyE1JLQcoqExOigOKaGqmfsGhJZDNDRGB7Ll74B97jq4b1BoOURDYzTwjcfPAQB+94vH8PFvPTMwoqZlGQ0NDY0+YW5+AX9013H58yBtzTq4a2hoaPQJt915DI0hVXnr4K6hoaHRJwzT1qyDu4aGhkafMMwqbx3cNTQ0NPqEYdqatVtGQ0NDo08Ypq1ZB3cNDQ2NPmJYtmYty2hoaGiMIHRw19DQ0BhB6OCuoaGhMYLQwV1DQ0NjBKGDu4aGhsYIgnHOh70NYIwtAng645/PADjXw83ZLLgU9/tS3Gfg0tzvS3GfgfT7/RzO+faoX2yI4N4NGGP3cM5vGPZ2DBqX4n5fivsMXJr7fSnuM9Db/dayjIaGhsYIQgd3DQ0NjRHEKAT3Dw97A4aES3G/L8V9Bi7N/b4U9xno4X5ves1dQ0NDQ6MVo8DcNTQ0NDRC0MFdQ0NDYwSxqYM7Y+x1jLFjjLHjjLH3DHt7+gHG2D7G2FcZYw8zxh5ijP2q9/pWxtiXGGOPef/fMuxt7QcYYwZjbJ4x9jnv5wOMsW975/xvGGOFYW9jL8EYm2aMfYYx9gPG2COMsZddCueaMfYfvev7QcbYJxhjpVE814yxjzLGzjLGHlReizy/TOAPvP2/nzH2wjTftWmDO2PMAPDHAF4P4CoAb2OMXTXcreoLbADv4pxfBeClAN7p7ed7AHyFc34QwFe8n0cRvwrgEeXn3wHwe5zz5wK4COAXhrJV/cP/BvBFzvnzAFwHse8jfa4ZY7MAfgXADZzzawAYAN6K0TzXHwPwutBrcef39QAOev+9A8CfpvmiTRvcAbwEwHHO+ROc8yaATwK4acjb1HNwzp/lnH/f+/cqxM0+C7Gvf+m97S8BHB3KBvYRjLG9AN4I4M+9nxmAVwH4jPeWkdpvxtgUgB8B8BEA4Jw3OedLuATONcRsiTJjLA+gAuBZjOC55px/HcCF0Mtx5/cmAH/FBb4FYJoxtjvpd23m4D4L4ITy80nvtZEFY2w/gMMAvg1gJ+f8We9XpwHsHNZ29RG/D+DdAGh8/DYAS5xz2/t51M75AQCLAP7Ck6L+nDE2hhE/15zzBQD/A8AzEEF9GcD3MNrnWkXc+e0qxm3m4H5JgTE2DuBvAfwa53xF/R0XftaR8rQyxt4E4Czn/HvD3pYBIg/ghQD+lHN+GMA6QhLMiJ7rLRAs9QCAPQDG0CpdXBLo5fndzMF9AcA+5ee93msjB8aYCRHYP845v917+Qwt0bz/nx3W9vUJNwJ4M2PsKQjJ7VUQevS0t3QHRu+cnwRwknP+be/nz0AE+1E/168B8CTnfJFzbgG4HeL8j/K5VhF3fruKcZs5uH8XwEEvo16ASMDcMeRt6jk8nfkjAB7hnP8v5Vd3APg5798/B+Czg962foJzfgvnfC/nfD/Eub2Lc/7TAL4K4Ce9t43UfnPOTwM4wRg75L30agAPY8TPNYQc81LGWMW73mm/R/ZchxB3fu8A8LOea+alAJYV+aYzOOeb9j8AbwDwKIDHAbx32NvTp318BcQy7X4A93r/vQFCf/4KgMcAfBnA1mFvax+PwSsBfM779+UAvgPgOIBPAygOe/t6vK/XA7jHO99zALZcCucawG8C+AGABwH8HwDFUTzXAD4BkVewIFZqvxB3fgEwCEfg4wAegHATJf4u3X5AQ0NDYwSxmWUZDQ0NDY0Y6OCuoaGhMYLQwV1DQ0NjBKGDu4aGhsYIQgd3DQ0NjRGEDu4aGhoaIwgd3DU0NDRGEP8/NsJkByhOb28AAAAASUVORK5CYII=\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.plot(fitness_list, 'o-')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Ant Colony Optimization"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "https://github.com/rochakgupta/aco-tsp"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import math\n",
+ "import random\n",
+ "from model.base_model import Model\n",
+ "\n",
+ "class MyACOModel(Model):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ "\n",
+ " class Edge:\n",
+ " def __init__(self, a, b, weight, initial_pheromone):\n",
+ " self.a = a\n",
+ " self.b = b\n",
+ " self.weight = weight\n",
+ " self.pheromone = initial_pheromone\n",
+ "\n",
+ " class Ant:\n",
+ " def __init__(self, alpha, beta, num_nodes, edges):\n",
+ " self.alpha = alpha\n",
+ " self.beta = beta\n",
+ " self.num_nodes = num_nodes\n",
+ " self.edges = edges\n",
+ " self.tour = None\n",
+ " self.distance = 0.0\n",
+ "\n",
+ " def _select_node(self):\n",
+ " roulette_wheel = 0.0\n",
+ " unvisited_nodes = [node for node in range(self.num_nodes) if node not in self.tour]\n",
+ " heuristic_total = 0.0\n",
+ " for unvisited_node in unvisited_nodes:\n",
+ " heuristic_total += self.edges[self.tour[-1]][unvisited_node].weight\n",
+ " for unvisited_node in unvisited_nodes:\n",
+ " roulette_wheel += pow(self.edges[self.tour[-1]][unvisited_node].pheromone, self.alpha) * \\\n",
+ " pow((heuristic_total / self.edges[self.tour[-1]][unvisited_node].weight), self.beta)\n",
+ " random_value = random.uniform(0.0, roulette_wheel)\n",
+ " wheel_position = 0.0\n",
+ " for unvisited_node in unvisited_nodes:\n",
+ " wheel_position += pow(self.edges[self.tour[-1]][unvisited_node].pheromone, self.alpha) * \\\n",
+ " pow((heuristic_total / self.edges[self.tour[-1]][unvisited_node].weight), self.beta)\n",
+ " if wheel_position >= random_value:\n",
+ " return unvisited_node\n",
+ "\n",
+ " def find_tour(self):\n",
+ " self.tour = [random.randint(0, self.num_nodes - 1)]\n",
+ " while len(self.tour) < self.num_nodes:\n",
+ " self.tour.append(self._select_node())\n",
+ " return self.tour\n",
+ "\n",
+ " def get_distance(self):\n",
+ " self.distance = 0.0\n",
+ " for i in range(self.num_nodes):\n",
+ " self.distance += self.edges[self.tour[i]][self.tour[(i + 1) % self.num_nodes]].weight\n",
+ " return self.distance\n",
+ "\n",
+ " def init(self, nodes, *args):\n",
+ " super().init(nodes)\n",
+ " mode, colony_size, elitist_weight, min_scaling_factor, alpha, beta, rho, pheromone_deposit_weight, initial_pheromone, labels = args\n",
+ "\n",
+ " self.mode = mode[0]\n",
+ " self.colony_size = colony_size\n",
+ " self.elitist_weight = elitist_weight\n",
+ " self.min_scaling_factor = min_scaling_factor\n",
+ " self.rho = rho\n",
+ " self.pheromone_deposit_weight = pheromone_deposit_weight\n",
+ " self.num_nodes = len(nodes)\n",
+ " self.nodes = nodes\n",
+ "\n",
+ " if labels is not None:\n",
+ " self.labels = labels\n",
+ " else:\n",
+ " self.labels = range(1, self.num_nodes + 1)\n",
+ " self.edges = [[None] * self.num_nodes for _ in range(self.num_nodes)]\n",
+ " for i in range(self.num_nodes):\n",
+ " for j in range(i + 1, self.num_nodes):\n",
+ " self.edges[i][j] = self.edges[j][i] = self.Edge(i, j, math.sqrt(\n",
+ " pow(self.nodes[i][0] - self.nodes[j][0], 2.0) + pow(self.nodes[i][1] - self.nodes[j][1], 2.0)),\n",
+ " initial_pheromone)\n",
+ " self.ants = [self.Ant(alpha, beta, self.num_nodes, self.edges) for _ in range(self.colony_size)]\n",
+ " self.global_best_tour = None\n",
+ " self.global_best_distance = float(\"inf\")\n",
+ "\n",
+ " def _add_pheromone(self, tour, distance, weight=1.0):\n",
+ " pheromone_to_add = self.pheromone_deposit_weight / distance\n",
+ " for i in range(self.num_nodes):\n",
+ " self.edges[tour[i]][tour[(i + 1) % self.num_nodes]].pheromone += weight * pheromone_to_add\n",
+ "\n",
+ " def _acs(self, max_it):\n",
+ " for step in range(0, max_it):\n",
+ "# print('[step]', step)\n",
+ " for ant in self.ants:\n",
+ " self._add_pheromone(ant.find_tour(), ant.get_distance())\n",
+ " if ant.distance < self.global_best_distance:\n",
+ " self.global_best_tour = ant.tour\n",
+ " self.global_best_distance = ant.distance\n",
+ " self.fitness_list.append(ant.distance)\n",
+ " for i in range(self.num_nodes):\n",
+ " for j in range(i + 1, self.num_nodes):\n",
+ " self.edges[i][j].pheromone *= (1.0 - self.rho)\n",
+ "\n",
+ " def _elitist(self, max_it):\n",
+ " for step in range(0, max_it):\n",
+ "# print('[step]', step)\n",
+ " for ant in self.ants:\n",
+ " self._add_pheromone(ant.find_tour(), ant.get_distance())\n",
+ " if ant.distance < self.global_best_distance:\n",
+ " self.global_best_tour = ant.tour\n",
+ " self.global_best_distance = ant.distance\n",
+ " self.fitness_list.append(ant.distance)\n",
+ " self._add_pheromone(self.global_best_tour, self.global_best_distance, weight=self.elitist_weight)\n",
+ " for i in range(self.num_nodes):\n",
+ " for j in range(i + 1, self.num_nodes):\n",
+ " self.edges[i][j].pheromone *= (1.0 - self.rho)\n",
+ "\n",
+ " def fit(self, max_it=1000):\n",
+ " \"\"\"\n",
+ " Execute simulated annealing algorithm.\n",
+ " \"\"\"\n",
+ " # Initialize with the greedy solution.\n",
+ " if self.mode == 'ACS':\n",
+ " self._acs(max_it)\n",
+ " elif self.mode == 'Elitist':\n",
+ " self._elitist(max_it)\n",
+ " else:\n",
+ " print(\"Un supported\")\n",
+ "# print('Sequence : <- {0} ->'.format(' - '.join(str(self.labels[i]) for i in self.global_best_tour)))\n",
+ "# print('Total distance travelled to complete the tour : {0}\\n'.format(round(self.global_best_distance, 2)))\n",
+ "\n",
+ " return self.global_best_tour, self.fitness_list"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tsp_file = './template/data/simple/ulysses16.tsp'"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Set hypter-parameters\n",
+ "mode='ACS', \n",
+ "colony_size=10\n",
+ "elitist_weight=1.0\n",
+ "min_scaling_factor=0.001\n",
+ "alpha=1.0\n",
+ "beta=3.0\n",
+ "rho=0.1\n",
+ "pheromone_deposit_weight=1.0\n",
+ "initial_pheromone=1.0\n",
+ "labels = None"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[*] [Node] 16, [Best] 74.1087359581531\n",
+ "[*] Running for: 1.61 seconds\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = MyACOModel()\n",
+ "best_solution, fitness_list, time = TSP_Bench(tsp_file, model, mode, colony_size, elitist_weight, min_scaling_factor, alpha, beta, rho, pheromone_deposit_weight, initial_pheromone, labels, max_it=1000, timeout=300)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Your Smart Model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import math\n",
+ "import random\n",
+ "from model.base_model import Model\n",
+ "\n",
+ "class MyModel(Model):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ "\n",
+ " def init(self, nodes):\n",
+ " \"\"\"\n",
+ " Put your initialization here.\n",
+ " \"\"\"\n",
+ " super().init(nodes)\n",
+ " self.log(\"Nothing to initialize in your model now\")\n",
+ "\n",
+ " def fit(self, max_it):\n",
+ " \"\"\"\n",
+ " Put your iteration process here.\n",
+ " \"\"\"\n",
+ " self.log(\"Naive Random Solution\")\n",
+ " self.best_solution = np.random.permutation(self.N).tolist()\n",
+ " self.fitness_list.append(self.fitness(self.best_solution))\n",
+ "\n",
+ " return self.best_solution, self.fitness_list"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Test your Model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tsp_problem = './template/data/simple/ulysses16.tsp'"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[MyModel] Nothing to initialize in your model now\n",
+ "[MyModel] Naive Random Solution\n",
+ "[*] [Node] 16, [Best] 149.95613345077442\n",
+ "[*] Running for: 0.00 seconds\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = MyModel()\n",
+ "best_solution, fitness_list, time = TSP_Bench(tsp_file, model)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Test All Dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "./template/data/medium/pcb442.tsp\n",
+ "./template/data/medium/a280.tsp\n",
+ "./template/data/hard/dsj1000.tsp\n",
+ "./template/data/simple/att48.tsp\n",
+ "./template/data/simple/ulysses16.tsp\n",
+ "./template/data/simple/st70.tsp\n"
+ ]
+ }
+ ],
+ "source": [
+ "for root, _, files in os.walk('./template/data'):\n",
+ " if(files):\n",
+ " for f in files:\n",
+ " print(str(root) + \"/\" + f)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def plot_results(best_solutions, times, title):\n",
+ " fig = plt.figure()\n",
+ " nodes = [len(s) for s in best_solutions]\n",
+ " data = np.array([[node, time] for node, time in sorted(zip(nodes, times))])\n",
+ " plt.plot(data[:, 0], data[:, 1], 'o-')\n",
+ " fig.suptitle(title, fontsize=20)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tsp_path = './template/data'"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Random Search\n",
+ "[*] ./template/data/medium/pcb442.tsp\n",
+ "[*] [Node] 442, [Best] 726804.3180499345\n",
+ "[*] Running for: 0.30 seconds\n",
+ "\n",
+ "[*] ./template/data/medium/a280.tsp\n",
+ "[*] [Node] 280, [Best] 30377.079411308096\n",
+ "[*] Running for: 0.18 seconds\n",
+ "\n",
+ "[*] ./template/data/hard/dsj1000.tsp\n",
+ "[*] [Node] 1000, [Best] 532033547.526717\n",
+ "[*] Running for: 0.71 seconds\n",
+ "\n",
+ "[*] ./template/data/simple/att48.tsp\n",
+ "[*] [Node] 48, [Best] 114552.11880841342\n",
+ "[*] Running for: 0.05 seconds\n",
+ "\n",
+ "[*] ./template/data/simple/ulysses16.tsp\n",
+ "[*] [Node] 16, [Best] 107.55064433885224\n",
+ "[*] Running for: 0.04 seconds\n",
+ "\n",
+ "[*] ./template/data/simple/st70.tsp\n",
+ "[*] [Node] 70, [Best] 3006.0125566251013\n",
+ "[*] Running for: 0.06 seconds\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = MyRandomModel()\n",
+ "\n",
+ "print(\"Random Search\")\n",
+ "best_solutions, fitness_lists, times = TSP_Bench_ALL(tsp_path, model)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plot_results(best_solutions, times, \"Random Model\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Set hypter-parameters\n",
+ "mode='ACS', \n",
+ "colony_size=10\n",
+ "elitist_weight=1.0\n",
+ "min_scaling_factor=0.001\n",
+ "alpha=1.0\n",
+ "beta=3.0\n",
+ "rho=0.1\n",
+ "pheromone_deposit_weight=1.0\n",
+ "initial_pheromone=1.0\n",
+ "labels = None"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Ant Colony Optimization\n",
+ "[*] ./template/data/medium/pcb442.tsp\n",
+ "[*] [Node] 442, [Best] 81773.39944759021\n",
+ "[*] Running for: 437.55 seconds\n",
+ "\n",
+ "[*] ./template/data/medium/a280.tsp\n",
+ "[*] [Node] 280, [Best] 3402.3354165651604\n",
+ "[*] Running for: 122.83 seconds\n",
+ "\n",
+ "[*] ./template/data/hard/dsj1000.tsp\n",
+ "[*] Timeout -3\n",
+ "[*] Running for: 600.01 seconds\n",
+ "\n",
+ "[*] ./template/data/simple/att48.tsp\n",
+ "[*] [Node] 48, [Best] 37903.563183654456\n",
+ "[*] Running for: 1.60 seconds\n",
+ "\n",
+ "[*] ./template/data/simple/ulysses16.tsp\n",
+ "[*] [Node] 16, [Best] 74.61480359572822\n",
+ "[*] Running for: 0.18 seconds\n",
+ "\n",
+ "[*] ./template/data/simple/st70.tsp\n",
+ "[*] [Node] 70, [Best] 758.1364540871836\n",
+ "[*] Running for: 3.71 seconds\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = MyACOModel()\n",
+ "\n",
+ "print(\"Ant Colony Optimization\")\n",
+ "best_solutions, fitness_lists, times = TSP_Bench_ALL(tsp_path, model, mode, colony_size, elitist_weight, min_scaling_factor, alpha, beta, rho, pheromone_deposit_weight, initial_pheromone, labels, max_it=100, timeout=600)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plot_results(best_solutions, times, \"Ant Colony Optimization\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "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.5"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/Workshop - 5 (PSO, ACO).ipynb b/Workshop - 5 (PSO, ACO).ipynb
new file mode 100644
index 0000000..e34325f
--- /dev/null
+++ b/Workshop - 5 (PSO, ACO).ipynb
@@ -0,0 +1,2278 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Make sure you run this at the begining**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import sys\n",
+ "import math\n",
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "# Append template path to sys path\n",
+ "sys.path.append(os.getcwd() + \"/template\") "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from utils.load_data import load_data\n",
+ "from utils.load_data import log\n",
+ "from utils.visualize_tsp import plotTSP\n",
+ "from utils.tsp import TSP"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Workshop Starts Here"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Get familiar with your dataset"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "There are problems at different levels. **3 simple, 2 medium, 1 hard**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "scrolled": false
+ },
+ "outputs": [],
+ "source": [
+ "for root, _, files in os.walk('./template/data'):\n",
+ " if(files):\n",
+ " for f in files:\n",
+ " print(str(root) + \"/\" + f)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ulysses16 = np.array(load_data(\"./template/data/simple/ulysses16.tsp\"))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ulysses16[:]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "plt.scatter(ulysses16[:, 0], ulysses16[:, 1])\n",
+ "for i in range(0, 16):\n",
+ " plt.annotate(i, (ulysses16[i, 0], ulysses16[i, 1]+0.5))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Naive Solution: In Order"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "simple_sequence = list(range(0, 16))\n",
+ "print(simple_sequence)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "plotTSP([simple_sequence], ulysses16, num_iters=1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Naive Solution: Random Permutation"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "random_permutation = np.random.permutation(16).tolist()\n",
+ "print(random_permutation)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "plotTSP([random_permutation], ulysses16, num_iters=1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Best Solution"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "best_ulysses16 = [0, 13, 12, 11, 6, 5, 14, 4, 10, 8, 9, 15, 2, 1, 3, 7]\n",
+ "plotTSP([best_ulysses16], ulysses16, num_iters=1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Calculate Fitness (Sum of all Distances)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def dist(node_0, node_1, coords):\n",
+ " \"\"\"\n",
+ " Euclidean distance between two nodes.\n",
+ " \"\"\"\n",
+ " coord_0, coord_1 = coords[node_0], coords[node_1]\n",
+ " return math.sqrt((coord_0[0] - coord_1[0]) ** 2 + (coord_0[1] - coord_1[1]) ** 2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(\"Coordinate of City 0:\", ulysses16[0])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(\"Coordinate of City 1:\", ulysses16[1])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "print(\"Distance Between\", dist(0, 1, ulysses16))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def fitness(solution, coords):\n",
+ " N = len(coords)\n",
+ " cur_fit = 0\n",
+ " for i in range(len(solution)):\n",
+ " cur_fit += dist(solution[i % N], solution[(i + 1) % N], coords)\n",
+ " return cur_fit"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print (\"Order Fitness:\\t\", fitness(simple_sequence, ulysses16))\n",
+ "print (\"Random Fitness:\\t\", fitness(random_permutation, ulysses16))\n",
+ "print (\"Best Fitness:\\t\", fitness(best_ulysses16, ulysses16))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Naive Random Model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import math\n",
+ "import random\n",
+ "from model.base_model import Model\n",
+ "\n",
+ "class MyModel(Model):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ "\n",
+ " def init(self, coords):\n",
+ " \"\"\"\n",
+ " Put your initialization here.\n",
+ " \"\"\"\n",
+ " super().init(coords)\n",
+ " self.log(\"Nothing to initialize in your model now\")\n",
+ "\n",
+ " def fit(self, max_it=1000, visualize=False):\n",
+ " \"\"\"\n",
+ " Put your iteration process here.\n",
+ " \"\"\"\n",
+ " self.log(\"Naive Random Solution\")\n",
+ " self.best_solution = np.random.permutation(self.N).tolist()\n",
+ " self.fitness_list.append(self.fitness(self.best_solution))\n",
+ "\n",
+ " return self.best_solution, self.fitness_list"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "tsp_problem = './template/data/simple/ulysses16.tsp'\n",
+ "tsp_coords = np.array(load_data(tsp_problem))\n",
+ "\n",
+ "import timeit\n",
+ "start = timeit.default_timer()\n",
+ "\n",
+ "# Your Model Running\n",
+ "\n",
+ "model = MyModel()\n",
+ "best_solution, fitness_list = TSP(tsp_problem, model)\n",
+ "\n",
+ "# Your Model End\n",
+ "\n",
+ "stop = timeit.default_timer()\n",
+ "print()\n",
+ "print('[*] Running for: {time:.1f} seconds'.format(time=(stop - start)))\n",
+ "\n",
+ "print()\n",
+ "print (\"Best Fitness:\\t\", fitness(best_solution, tsp_coords))\n",
+ "print (\"Best Solution:\\t\", best_solution)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Minimum Spanning Tree (Depth First)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 85,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import math\n",
+ "import random\n",
+ "from model.base_model import Model\n",
+ "\n",
+ "class MyModel(Model):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ "\n",
+ " def init(self, coords):\n",
+ " \"\"\"\n",
+ " Put your initialization here.\n",
+ " \"\"\"\n",
+ " super().init(coords)\n",
+ " self.log(\"Nothing to initialize in your model now\")\n",
+ "\n",
+ " def fit(self, max_it=1000, visualize=False):\n",
+ " \"\"\"\n",
+ " Put your iteration process here.\n",
+ " \"\"\"\n",
+ " self.log(\"Uniform Cost Search Solution\")\n",
+ "\n",
+ " UCS_solutions = []\n",
+ " UCS_losses = []\n",
+ " # Depth First: Set one city as starting point, iterate to the end, then select next city as starting point.\n",
+ " for i in range(0, self.N):\n",
+ " solution = []\n",
+ " solution.append(i)\n",
+ " unvisited_list = list(range(0, self.N))\n",
+ " cur_city = i\n",
+ " print(\"[starting]\", i)\n",
+ " for steps in range(self.N - 1):\n",
+ " # print(unvisited_list)\n",
+ " unvisited_list.remove(cur_city)\n",
+ " closest_neighbour = -1\n",
+ " shortest_distance = math.inf\n",
+ " for j in unvisited_list:\n",
+ " if(self.dist(cur_city, j) < shortest_distance):\n",
+ " closest_neighbour = j\n",
+ " shortest_distance = self.dist(cur_city, j)\n",
+ " solution.append(closest_neighbour)\n",
+ " cur_city = closest_neighbour\n",
+ " UCS_solutions.append(solution)\n",
+ " UCS_losses.append(self.fitness(solution))\n",
+ "\n",
+ " self.best_solution = UCS_solutions[ UCS_losses.index(min(UCS_losses)) ]\n",
+ " self.fitness_list.append(self.fitness(self.best_solution))\n",
+ "\n",
+ " return self.best_solution, self.fitness_list"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 86,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[MyModel] Nothing to initialize in your model now\n",
+ "[MyModel] Uniform Cost Search Solution\n",
+ "[starting] 0\n",
+ "[starting] 1\n",
+ "[starting] 2\n",
+ "[starting] 3\n",
+ "[starting] 4\n",
+ "[starting] 5\n",
+ "[starting] 6\n",
+ "[starting] 7\n",
+ "[starting] 8\n",
+ "[starting] 9\n",
+ "[starting] 10\n",
+ "[starting] 11\n",
+ "[starting] 12\n",
+ "[starting] 13\n",
+ "[starting] 14\n",
+ "[starting] 15\n",
+ "[starting] 16\n",
+ "[starting] 17\n",
+ "[starting] 18\n",
+ "[starting] 19\n",
+ "[starting] 20\n",
+ "[starting] 21\n",
+ "[starting] 22\n",
+ "[starting] 23\n",
+ "[starting] 24\n",
+ "[starting] 25\n",
+ "[starting] 26\n",
+ "[starting] 27\n",
+ "[starting] 28\n",
+ "[starting] 29\n",
+ "[starting] 30\n",
+ "[starting] 31\n",
+ "[starting] 32\n",
+ "[starting] 33\n",
+ "[starting] 34\n",
+ "[starting] 35\n",
+ "[starting] 36\n",
+ "[starting] 37\n",
+ "[starting] 38\n",
+ "[starting] 39\n",
+ "[starting] 40\n",
+ "[starting] 41\n",
+ "[starting] 42\n",
+ "[starting] 43\n",
+ "[starting] 44\n",
+ "[starting] 45\n",
+ "[starting] 46\n",
+ "[starting] 47\n",
+ "[starting] 48\n",
+ "[starting] 49\n",
+ "[starting] 50\n",
+ "[starting] 51\n",
+ "[starting] 52\n",
+ "[starting] 53\n",
+ "[starting] 54\n",
+ "[starting] 55\n",
+ "[starting] 56\n",
+ "[starting] 57\n",
+ "[starting] 58\n",
+ "[starting] 59\n",
+ "[starting] 60\n",
+ "[starting] 61\n",
+ "[starting] 62\n",
+ "[starting] 63\n",
+ "[starting] 64\n",
+ "[starting] 65\n",
+ "[starting] 66\n",
+ "[starting] 67\n",
+ "[starting] 68\n",
+ "[starting] 69\n",
+ "[starting] 70\n",
+ "[starting] 71\n",
+ "[starting] 72\n",
+ "[starting] 73\n",
+ "[starting] 74\n",
+ "[starting] 75\n",
+ "[starting] 76\n",
+ "[starting] 77\n",
+ "[starting] 78\n",
+ "[starting] 79\n",
+ "[starting] 80\n",
+ "[starting] 81\n",
+ "[starting] 82\n",
+ "[starting] 83\n",
+ "[starting] 84\n",
+ "[starting] 85\n",
+ "[starting] 86\n",
+ "[starting] 87\n",
+ "[starting] 88\n",
+ "[starting] 89\n",
+ "[starting] 90\n",
+ "[starting] 91\n",
+ "[starting] 92\n",
+ "[starting] 93\n",
+ "[starting] 94\n",
+ "[starting] 95\n",
+ "[starting] 96\n",
+ "[starting] 97\n",
+ "[starting] 98\n",
+ "[starting] 99\n",
+ "[starting] 100\n",
+ "[starting] 101\n",
+ "[starting] 102\n",
+ "[starting] 103\n",
+ "[starting] 104\n",
+ "[starting] 105\n",
+ "[starting] 106\n",
+ "[starting] 107\n",
+ "[starting] 108\n",
+ "[starting] 109\n",
+ "[starting] 110\n",
+ "[starting] 111\n",
+ "[starting] 112\n",
+ "[starting] 113\n",
+ "[starting] 114\n",
+ "[starting] 115\n",
+ "[starting] 116\n",
+ "[starting] 117\n",
+ "[starting] 118\n",
+ "[starting] 119\n",
+ "[starting] 120\n",
+ "[starting] 121\n",
+ "[starting] 122\n",
+ "[starting] 123\n",
+ "[starting] 124\n",
+ "[starting] 125\n",
+ "[starting] 126\n",
+ "[starting] 127\n",
+ "[starting] 128\n",
+ "[starting] 129\n",
+ "[starting] 130\n",
+ "[starting] 131\n",
+ "[starting] 132\n",
+ "[starting] 133\n",
+ "[starting] 134\n",
+ "[starting] 135\n",
+ "[starting] 136\n",
+ "[starting] 137\n",
+ "[starting] 138\n",
+ "[starting] 139\n",
+ "[starting] 140\n",
+ "[starting] 141\n",
+ "[starting] 142\n",
+ "[starting] 143\n",
+ "[starting] 144\n",
+ "[starting] 145\n",
+ "[starting] 146\n",
+ "[starting] 147\n",
+ "[starting] 148\n",
+ "[starting] 149\n",
+ "[starting] 150\n",
+ "[starting] 151\n",
+ "[starting] 152\n",
+ "[starting] 153\n",
+ "[starting] 154\n",
+ "[starting] 155\n",
+ "[starting] 156\n",
+ "[starting] 157\n",
+ "[starting] 158\n",
+ "[starting] 159\n",
+ "[starting] 160\n",
+ "[starting] 161\n",
+ "[starting] 162\n",
+ "[starting] 163\n",
+ "[starting] 164\n",
+ "[starting] 165\n",
+ "[starting] 166\n",
+ "[starting] 167\n",
+ "[starting] 168\n",
+ "[starting] 169\n",
+ "[starting] 170\n",
+ "[starting] 171\n",
+ "[starting] 172\n",
+ "[starting] 173\n",
+ "[starting] 174\n",
+ "[starting] 175\n",
+ "[starting] 176\n",
+ "[starting] 177\n",
+ "[starting] 178\n",
+ "[starting] 179\n",
+ "[starting] 180\n",
+ "[starting] 181\n",
+ "[starting] 182\n",
+ "[starting] 183\n",
+ "[starting] 184\n",
+ "[starting] 185\n",
+ "[starting] 186\n",
+ "[starting] 187\n",
+ "[starting] 188\n",
+ "[starting] 189\n",
+ "[starting] 190\n",
+ "[starting] 191\n",
+ "[starting] 192\n",
+ "[starting] 193\n",
+ "[starting] 194\n",
+ "[starting] 195\n",
+ "[starting] 196\n",
+ "[starting] 197\n",
+ "[starting] 198\n",
+ "[starting] 199\n",
+ "[starting] 200\n",
+ "[starting] 201\n",
+ "[starting] 202\n",
+ "[starting] 203\n",
+ "[starting] 204\n",
+ "[starting] 205\n",
+ "[starting] 206\n",
+ "[starting] 207\n",
+ "[starting] 208\n",
+ "[starting] 209\n",
+ "[starting] 210\n",
+ "[starting] 211\n",
+ "[starting] 212\n",
+ "[starting] 213\n",
+ "[starting] 214\n",
+ "[starting] 215\n",
+ "[starting] 216\n",
+ "[starting] 217\n",
+ "[starting] 218\n",
+ "[starting] 219\n",
+ "[starting] 220\n",
+ "[starting] 221\n",
+ "[starting] 222\n",
+ "[starting] 223\n",
+ "[starting] 224\n",
+ "[starting] 225\n",
+ "[starting] 226\n",
+ "[starting] 227\n",
+ "[starting] 228\n",
+ "[starting] 229\n",
+ "[starting] 230\n",
+ "[starting] 231\n",
+ "[starting] 232\n",
+ "[starting] 233\n",
+ "[starting] 234\n",
+ "[starting] 235\n",
+ "[starting] 236\n",
+ "[starting] 237\n",
+ "[starting] 238\n",
+ "[starting] 239\n",
+ "[starting] 240\n",
+ "[starting] 241\n",
+ "[starting] 242\n",
+ "[starting] 243\n",
+ "[starting] 244\n",
+ "[starting] 245\n",
+ "[starting] 246\n",
+ "[starting] 247\n",
+ "[starting] 248\n",
+ "[starting] 249\n",
+ "[starting] 250\n",
+ "[starting] 251\n",
+ "[starting] 252\n",
+ "[starting] 253\n",
+ "[starting] 254\n",
+ "[starting] 255\n",
+ "[starting] 256\n",
+ "[starting] 257\n",
+ "[starting] 258\n",
+ "[starting] 259\n",
+ "[starting] 260\n",
+ "[starting] 261\n",
+ "[starting] 262\n",
+ "[starting] 263\n",
+ "[starting] 264\n",
+ "[starting] 265\n",
+ "[starting] 266\n",
+ "[starting] 267\n",
+ "[starting] 268\n",
+ "[starting] 269\n",
+ "[starting] 270\n",
+ "[starting] 271\n",
+ "[starting] 272\n",
+ "[starting] 273\n",
+ "[starting] 274\n",
+ "[starting] 275\n",
+ "[starting] 276\n",
+ "[starting] 277\n",
+ "[starting] 278\n",
+ "[starting] 279\n",
+ "[starting] 280\n",
+ "[starting] 281\n",
+ "[starting] 282\n",
+ "[starting] 283\n",
+ "[starting] 284\n",
+ "[starting] 285\n",
+ "[starting] 286\n",
+ "[starting] 287\n",
+ "[starting] 288\n",
+ "[starting] 289\n",
+ "[starting] 290\n",
+ "[starting] 291\n",
+ "[starting] 292\n",
+ "[starting] 293\n",
+ "[starting] 294\n",
+ "[starting] 295\n",
+ "[starting] 296\n",
+ "[starting] 297\n",
+ "[starting] 298\n",
+ "[starting] 299\n",
+ "[starting] 300\n",
+ "[starting] 301\n",
+ "[starting] 302\n",
+ "[starting] 303\n",
+ "[starting] 304\n",
+ "[starting] 305\n",
+ "[starting] 306\n",
+ "[starting] 307\n",
+ "[starting] 308\n",
+ "[starting] 309\n",
+ "[starting] 310\n",
+ "[starting] 311\n",
+ "[starting] 312\n",
+ "[starting] 313\n",
+ "[starting] 314\n",
+ "[starting] 315\n",
+ "[starting] 316\n",
+ "[starting] 317\n",
+ "[starting] 318\n",
+ "[starting] 319\n",
+ "[starting] 320\n",
+ "[starting] 321\n",
+ "[starting] 322\n",
+ "[starting] 323\n",
+ "[starting] 324\n",
+ "[starting] 325\n",
+ "[starting] 326\n",
+ "[starting] 327\n",
+ "[starting] 328\n",
+ "[starting] 329\n",
+ "[starting] 330\n",
+ "[starting] 331\n",
+ "[starting] 332\n",
+ "[starting] 333\n",
+ "[starting] 334\n",
+ "[starting] 335\n",
+ "[starting] 336\n",
+ "[starting] 337\n",
+ "[starting] 338\n",
+ "[starting] 339\n",
+ "[starting] 340\n",
+ "[starting] 341\n",
+ "[starting] 342\n",
+ "[starting] 343\n",
+ "[starting] 344\n",
+ "[starting] 345\n",
+ "[starting] 346\n",
+ "[starting] 347\n",
+ "[starting] 348\n",
+ "[starting] 349\n",
+ "[starting] 350\n",
+ "[starting] 351\n",
+ "[starting] 352\n",
+ "[starting] 353\n",
+ "[starting] 354\n",
+ "[starting] 355\n",
+ "[starting] 356\n",
+ "[starting] 357\n",
+ "[starting] 358\n",
+ "[starting] 359\n",
+ "[starting] 360\n",
+ "[starting] 361\n",
+ "[starting] 362\n",
+ "[starting] 363\n",
+ "[starting] 364\n",
+ "[starting] 365\n",
+ "[starting] 366\n",
+ "[starting] 367\n",
+ "[starting] 368\n",
+ "[starting] 369\n",
+ "[starting] 370\n",
+ "[starting] 371\n",
+ "[starting] 372\n",
+ "[starting] 373\n",
+ "[starting] 374\n",
+ "[starting] 375\n",
+ "[starting] 376\n",
+ "[starting] 377\n",
+ "[starting] 378\n",
+ "[starting] 379\n",
+ "[starting] 380\n",
+ "[starting] 381\n",
+ "[starting] 382\n",
+ "[starting] 383\n",
+ "[starting] 384\n",
+ "[starting] 385\n",
+ "[starting] 386\n",
+ "[starting] 387\n",
+ "[starting] 388\n",
+ "[starting] 389\n",
+ "[starting] 390\n",
+ "[starting] 391\n",
+ "[starting] 392\n",
+ "[starting] 393\n",
+ "[starting] 394\n",
+ "[starting] 395\n",
+ "[starting] 396\n",
+ "[starting] 397\n",
+ "[starting] 398\n",
+ "[starting] 399\n",
+ "[starting] 400\n",
+ "[starting] 401\n",
+ "[starting] 402\n",
+ "[starting] 403\n",
+ "[starting] 404\n",
+ "[starting] 405\n",
+ "[starting] 406\n",
+ "[starting] 407\n",
+ "[starting] 408\n",
+ "[starting] 409\n",
+ "[starting] 410\n",
+ "[starting] 411\n",
+ "[starting] 412\n",
+ "[starting] 413\n",
+ "[starting] 414\n",
+ "[starting] 415\n",
+ "[starting] 416\n",
+ "[starting] 417\n",
+ "[starting] 418\n",
+ "[starting] 419\n",
+ "[starting] 420\n",
+ "[starting] 421\n",
+ "[starting] 422\n",
+ "[starting] 423\n",
+ "[starting] 424\n",
+ "[starting] 425\n",
+ "[starting] 426\n",
+ "[starting] 427\n",
+ "[starting] 428\n",
+ "[starting] 429\n",
+ "[starting] 430\n",
+ "[starting] 431\n",
+ "[starting] 432\n",
+ "[starting] 433\n",
+ "[starting] 434\n",
+ "[starting] 435\n",
+ "[starting] 436\n",
+ "[starting] 437\n",
+ "[starting] 438\n",
+ "[starting] 439\n",
+ "[starting] 440\n",
+ "[starting] 441\n",
+ "[*] Best: 58952.967129705365\n",
+ "[*] Writing the best solution to file\n",
+ "\n",
+ "[*] Running for: 18.7 seconds\n",
+ "\n",
+ "Best Fitness:\t 58952.967129705365\n",
+ "Best Solution:\t [395, 173, 172, 161, 149, 136, 126, 385, 114, 103, 440, 101, 102, 113, 125, 135, 148, 160, 171, 184, 399, 404, 226, 233, 237, 238, 265, 268, 272, 275, 278, 280, 281, 427, 341, 340, 345, 346, 347, 432, 348, 349, 350, 351, 342, 352, 353, 354, 433, 355, 356, 357, 434, 358, 359, 360, 343, 361, 362, 363, 364, 365, 366, 344, 367, 368, 369, 370, 371, 372, 373, 374, 337, 336, 426, 335, 334, 333, 306, 332, 331, 330, 305, 304, 303, 302, 301, 300, 299, 298, 297, 296, 295, 294, 293, 292, 291, 290, 289, 288, 287, 286, 285, 284, 283, 282, 279, 425, 439, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 428, 324, 325, 326, 327, 328, 329, 430, 429, 277, 416, 417, 252, 251, 250, 249, 414, 248, 247, 246, 245, 244, 243, 242, 241, 240, 239, 234, 227, 405, 400, 185, 398, 186, 174, 391, 137, 115, 388, 386, 150, 151, 392, 152, 138, 127, 116, 104, 105, 106, 117, 128, 140, 153, 164, 163, 176, 188, 200, 401, 201, 189, 190, 397, 177, 165, 154, 141, 129, 118, 107, 438, 82, 50, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 81, 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 65, 441, 98, 99, 83, 51, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 375, 376, 32, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 84, 85, 86, 377, 87, 88, 89, 90, 91, 92, 93, 94, 378, 95, 379, 96, 97, 382, 383, 112, 124, 134, 147, 159, 170, 183, 198, 209, 219, 225, 410, 409, 413, 236, 264, 419, 267, 415, 263, 262, 235, 261, 260, 259, 258, 257, 256, 255, 254, 253, 231, 223, 214, 202, 178, 394, 393, 166, 155, 142, 130, 119, 108, 384, 120, 121, 109, 131, 144, 143, 390, 156, 167, 180, 193, 204, 205, 206, 194, 195, 196, 181, 168, 157, 145, 132, 122, 110, 100, 435, 111, 123, 133, 146, 158, 169, 182, 197, 208, 218, 217, 207, 216, 403, 408, 407, 411, 412, 418, 421, 437, 422, 271, 274, 436, 431, 232, 224, 215, 203, 191, 179, 192, 389, 387, 380, 381, 139, 162, 175, 187, 199, 212, 221, 229, 228, 220, 210, 402, 211, 396, 213, 222, 230, 424, 420, 423, 339, 338, 276, 273, 270, 266, 269, 406]\n"
+ ]
+ }
+ ],
+ "source": [
+ "tsp_problem = './template/data/medium/pcb442.tsp'\n",
+ "tsp_coords = np.array(load_data(tsp_problem))\n",
+ "\n",
+ "import timeit\n",
+ "start = timeit.default_timer()\n",
+ "\n",
+ "# Your Model Running\n",
+ "\n",
+ "model = MyModel()\n",
+ "best_solution, fitness_list = TSP(tsp_problem, model)\n",
+ "\n",
+ "# Your Model End\n",
+ "\n",
+ "stop = timeit.default_timer()\n",
+ "print()\n",
+ "print('[*] Running for: {time:.1f} seconds'.format(time=(stop - start)))\n",
+ "\n",
+ "print()\n",
+ "print (\"Best Fitness:\\t\", fitness(best_solution, tsp_coords))\n",
+ "print (\"Best Solution:\\t\", best_solution)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Minimum Spanning Tree (Breadth First)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 87,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import math\n",
+ "import random\n",
+ "from model.base_model import Model\n",
+ "\n",
+ "class MyModel(Model):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ "\n",
+ " def init(self, coords):\n",
+ " \"\"\"\n",
+ " Put your initialization here.\n",
+ " \"\"\"\n",
+ " super().init(coords)\n",
+ " self.log(\"Nothing to initialize in your model now\")\n",
+ "\n",
+ " def fit(self, max_it=1000, visualize=False):\n",
+ " \"\"\"\n",
+ " Put your iteration process here.\n",
+ " \"\"\"\n",
+ " self.log(\"Uniform Cost Search Solution\")\n",
+ "\n",
+ " UCS_solutions = []\n",
+ " UCS_losses = []\n",
+ " \n",
+ " for i in range(0, self.N):\n",
+ " solution = [i]\n",
+ " UCS_solutions.append(solution)\n",
+ " \n",
+ " # Breadth First: Set each city as starting point, then go to next city simultaneously\n",
+ " for step in range(0, self.N - 1):\n",
+ " print(\"[step]\", step)\n",
+ " UCS_solutions[i]\n",
+ " solution = []\n",
+ " solution.append(i)\n",
+ " unvisited_list = list(range(0, self.N))\n",
+ " cur_city = i\n",
+ " # For each search path\n",
+ " for i in range(0, self.N):\n",
+ " cur_city = UCS_solutions[i][step]\n",
+ " unvisited_list = list( set(range(0, self.N)) - set(UCS_solutions[i]) )\n",
+ " # print(unvisited_list)\n",
+ " closest_neighbour = -1\n",
+ " shortest_distance = math.inf\n",
+ " for j in unvisited_list:\n",
+ " if(self.dist(cur_city, j) < shortest_distance):\n",
+ " closest_neighbour = j\n",
+ " shortest_distance = self.dist(cur_city, j)\n",
+ " UCS_solutions[i].append(closest_neighbour)\n",
+ "\n",
+ " for i in range(0, self.N):\n",
+ " UCS_losses.append(self.fitness(UCS_solutions[i]))\n",
+ " \n",
+ " self.best_solution = UCS_solutions[ UCS_losses.index(min(UCS_losses)) ]\n",
+ " self.fitness_list.append(self.fitness(self.best_solution))\n",
+ "\n",
+ " return self.best_solution, self.fitness_list"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 89,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[MyModel] Nothing to initialize in your model now\n",
+ "[MyModel] Uniform Cost Search Solution\n",
+ "[step] 0\n",
+ "[step] 1\n",
+ "[step] 2\n",
+ "[step] 3\n",
+ "[step] 4\n",
+ "[step] 5\n",
+ "[step] 6\n",
+ "[step] 7\n",
+ "[step] 8\n",
+ "[step] 9\n",
+ "[step] 10\n",
+ "[step] 11\n",
+ "[step] 12\n",
+ "[step] 13\n",
+ "[step] 14\n",
+ "[step] 15\n",
+ "[step] 16\n",
+ "[step] 17\n",
+ "[step] 18\n",
+ "[step] 19\n",
+ "[step] 20\n",
+ "[step] 21\n",
+ "[step] 22\n",
+ "[step] 23\n",
+ "[step] 24\n",
+ "[step] 25\n",
+ "[step] 26\n",
+ "[step] 27\n",
+ "[step] 28\n",
+ "[step] 29\n",
+ "[step] 30\n",
+ "[step] 31\n",
+ "[step] 32\n",
+ "[step] 33\n",
+ "[step] 34\n",
+ "[step] 35\n",
+ "[step] 36\n",
+ "[step] 37\n",
+ "[step] 38\n",
+ "[step] 39\n",
+ "[step] 40\n",
+ "[step] 41\n",
+ "[step] 42\n",
+ "[step] 43\n",
+ "[step] 44\n",
+ "[step] 45\n",
+ "[step] 46\n",
+ "[step] 47\n",
+ "[step] 48\n",
+ "[step] 49\n",
+ "[step] 50\n",
+ "[step] 51\n",
+ "[step] 52\n",
+ "[step] 53\n",
+ "[step] 54\n",
+ "[step] 55\n",
+ "[step] 56\n",
+ "[step] 57\n",
+ "[step] 58\n",
+ "[step] 59\n",
+ "[step] 60\n",
+ "[step] 61\n",
+ "[step] 62\n",
+ "[step] 63\n",
+ "[step] 64\n",
+ "[step] 65\n",
+ "[step] 66\n",
+ "[step] 67\n",
+ "[step] 68\n",
+ "[step] 69\n",
+ "[step] 70\n",
+ "[step] 71\n",
+ "[step] 72\n",
+ "[step] 73\n",
+ "[step] 74\n",
+ "[step] 75\n",
+ "[step] 76\n",
+ "[step] 77\n",
+ "[step] 78\n",
+ "[step] 79\n",
+ "[step] 80\n",
+ "[step] 81\n",
+ "[step] 82\n",
+ "[step] 83\n",
+ "[step] 84\n",
+ "[step] 85\n",
+ "[step] 86\n",
+ "[step] 87\n",
+ "[step] 88\n",
+ "[step] 89\n",
+ "[step] 90\n",
+ "[step] 91\n",
+ "[step] 92\n",
+ "[step] 93\n",
+ "[step] 94\n",
+ "[step] 95\n",
+ "[step] 96\n",
+ "[step] 97\n",
+ "[step] 98\n",
+ "[step] 99\n",
+ "[step] 100\n",
+ "[step] 101\n",
+ "[step] 102\n",
+ "[step] 103\n",
+ "[step] 104\n",
+ "[step] 105\n",
+ "[step] 106\n",
+ "[step] 107\n",
+ "[step] 108\n",
+ "[step] 109\n",
+ "[step] 110\n",
+ "[step] 111\n",
+ "[step] 112\n",
+ "[step] 113\n",
+ "[step] 114\n",
+ "[step] 115\n",
+ "[step] 116\n",
+ "[step] 117\n",
+ "[step] 118\n",
+ "[step] 119\n",
+ "[step] 120\n",
+ "[step] 121\n",
+ "[step] 122\n",
+ "[step] 123\n",
+ "[step] 124\n",
+ "[step] 125\n",
+ "[step] 126\n",
+ "[step] 127\n",
+ "[step] 128\n",
+ "[step] 129\n",
+ "[step] 130\n",
+ "[step] 131\n",
+ "[step] 132\n",
+ "[step] 133\n",
+ "[step] 134\n",
+ "[step] 135\n",
+ "[step] 136\n",
+ "[step] 137\n",
+ "[step] 138\n",
+ "[step] 139\n",
+ "[step] 140\n",
+ "[step] 141\n",
+ "[step] 142\n",
+ "[step] 143\n",
+ "[step] 144\n",
+ "[step] 145\n",
+ "[step] 146\n",
+ "[step] 147\n",
+ "[step] 148\n",
+ "[step] 149\n",
+ "[step] 150\n",
+ "[step] 151\n",
+ "[step] 152\n",
+ "[step] 153\n",
+ "[step] 154\n",
+ "[step] 155\n",
+ "[step] 156\n",
+ "[step] 157\n",
+ "[step] 158\n",
+ "[step] 159\n",
+ "[step] 160\n",
+ "[step] 161\n",
+ "[step] 162\n",
+ "[step] 163\n",
+ "[step] 164\n",
+ "[step] 165\n",
+ "[step] 166\n",
+ "[step] 167\n",
+ "[step] 168\n",
+ "[step] 169\n",
+ "[step] 170\n",
+ "[step] 171\n",
+ "[step] 172\n",
+ "[step] 173\n",
+ "[step] 174\n",
+ "[step] 175\n",
+ "[step] 176\n",
+ "[step] 177\n",
+ "[step] 178\n",
+ "[step] 179\n",
+ "[step] 180\n",
+ "[step] 181\n",
+ "[step] 182\n",
+ "[step] 183\n",
+ "[step] 184\n",
+ "[step] 185\n",
+ "[step] 186\n",
+ "[step] 187\n",
+ "[step] 188\n",
+ "[step] 189\n",
+ "[step] 190\n",
+ "[step] 191\n",
+ "[step] 192\n",
+ "[step] 193\n",
+ "[step] 194\n",
+ "[step] 195\n",
+ "[step] 196\n",
+ "[step] 197\n",
+ "[step] 198\n",
+ "[step] 199\n",
+ "[step] 200\n",
+ "[step] 201\n",
+ "[step] 202\n",
+ "[step] 203\n",
+ "[step] 204\n",
+ "[step] 205\n",
+ "[step] 206\n",
+ "[step] 207\n",
+ "[step] 208\n",
+ "[step] 209\n",
+ "[step] 210\n",
+ "[step] 211\n",
+ "[step] 212\n",
+ "[step] 213\n",
+ "[step] 214\n",
+ "[step] 215\n",
+ "[step] 216\n",
+ "[step] 217\n",
+ "[step] 218\n",
+ "[step] 219\n",
+ "[step] 220\n",
+ "[step] 221\n",
+ "[step] 222\n",
+ "[step] 223\n",
+ "[step] 224\n",
+ "[step] 225\n",
+ "[step] 226\n",
+ "[step] 227\n",
+ "[step] 228\n",
+ "[step] 229\n",
+ "[step] 230\n",
+ "[step] 231\n",
+ "[step] 232\n",
+ "[step] 233\n",
+ "[step] 234\n",
+ "[step] 235\n",
+ "[step] 236\n",
+ "[step] 237\n",
+ "[step] 238\n",
+ "[step] 239\n",
+ "[step] 240\n",
+ "[step] 241\n",
+ "[step] 242\n",
+ "[step] 243\n",
+ "[step] 244\n",
+ "[step] 245\n",
+ "[step] 246\n",
+ "[step] 247\n",
+ "[step] 248\n",
+ "[step] 249\n",
+ "[step] 250\n",
+ "[step] 251\n",
+ "[step] 252\n",
+ "[step] 253\n",
+ "[step] 254\n",
+ "[step] 255\n",
+ "[step] 256\n",
+ "[step] 257\n",
+ "[step] 258\n",
+ "[step] 259\n",
+ "[step] 260\n",
+ "[step] 261\n",
+ "[step] 262\n",
+ "[step] 263\n",
+ "[step] 264\n",
+ "[step] 265\n",
+ "[step] 266\n",
+ "[step] 267\n",
+ "[step] 268\n",
+ "[step] 269\n",
+ "[step] 270\n",
+ "[step] 271\n",
+ "[step] 272\n",
+ "[step] 273\n",
+ "[step] 274\n",
+ "[step] 275\n",
+ "[step] 276\n",
+ "[step] 277\n",
+ "[step] 278\n",
+ "[step] 279\n",
+ "[step] 280\n",
+ "[step] 281\n",
+ "[step] 282\n",
+ "[step] 283\n",
+ "[step] 284\n",
+ "[step] 285\n",
+ "[step] 286\n",
+ "[step] 287\n",
+ "[step] 288\n",
+ "[step] 289\n",
+ "[step] 290\n",
+ "[step] 291\n",
+ "[step] 292\n",
+ "[step] 293\n",
+ "[step] 294\n",
+ "[step] 295\n",
+ "[step] 296\n",
+ "[step] 297\n",
+ "[step] 298\n",
+ "[step] 299\n",
+ "[step] 300\n",
+ "[step] 301\n",
+ "[step] 302\n",
+ "[step] 303\n",
+ "[step] 304\n",
+ "[step] 305\n",
+ "[step] 306\n",
+ "[step] 307\n",
+ "[step] 308\n",
+ "[step] 309\n",
+ "[step] 310\n",
+ "[step] 311\n",
+ "[step] 312\n",
+ "[step] 313\n",
+ "[step] 314\n",
+ "[step] 315\n",
+ "[step] 316\n",
+ "[step] 317\n",
+ "[step] 318\n",
+ "[step] 319\n",
+ "[step] 320\n",
+ "[step] 321\n",
+ "[step] 322\n",
+ "[step] 323\n",
+ "[step] 324\n",
+ "[step] 325\n",
+ "[step] 326\n",
+ "[step] 327\n",
+ "[step] 328\n",
+ "[step] 329\n",
+ "[step] 330\n",
+ "[step] 331\n",
+ "[step] 332\n",
+ "[step] 333\n",
+ "[step] 334\n",
+ "[step] 335\n",
+ "[step] 336\n",
+ "[step] 337\n",
+ "[step] 338\n",
+ "[step] 339\n",
+ "[step] 340\n",
+ "[step] 341\n",
+ "[step] 342\n",
+ "[step] 343\n",
+ "[step] 344\n",
+ "[step] 345\n",
+ "[step] 346\n",
+ "[step] 347\n",
+ "[step] 348\n",
+ "[step] 349\n",
+ "[step] 350\n",
+ "[step] 351\n",
+ "[step] 352\n",
+ "[step] 353\n",
+ "[step] 354\n",
+ "[step] 355\n",
+ "[step] 356\n",
+ "[step] 357\n",
+ "[step] 358\n",
+ "[step] 359\n",
+ "[step] 360\n",
+ "[step] 361\n",
+ "[step] 362\n",
+ "[step] 363\n",
+ "[step] 364\n",
+ "[step] 365\n",
+ "[step] 366\n",
+ "[step] 367\n",
+ "[step] 368\n",
+ "[step] 369\n",
+ "[step] 370\n",
+ "[step] 371\n",
+ "[step] 372\n",
+ "[step] 373\n",
+ "[step] 374\n",
+ "[step] 375\n",
+ "[step] 376\n",
+ "[step] 377\n",
+ "[step] 378\n",
+ "[step] 379\n",
+ "[step] 380\n",
+ "[step] 381\n",
+ "[step] 382\n",
+ "[step] 383\n",
+ "[step] 384\n",
+ "[step] 385\n",
+ "[step] 386\n",
+ "[step] 387\n",
+ "[step] 388\n",
+ "[step] 389\n",
+ "[step] 390\n",
+ "[step] 391\n",
+ "[step] 392\n",
+ "[step] 393\n",
+ "[step] 394\n",
+ "[step] 395\n",
+ "[step] 396\n",
+ "[step] 397\n",
+ "[step] 398\n",
+ "[step] 399\n",
+ "[step] 400\n",
+ "[step] 401\n",
+ "[step] 402\n",
+ "[step] 403\n",
+ "[step] 404\n",
+ "[step] 405\n",
+ "[step] 406\n",
+ "[step] 407\n",
+ "[step] 408\n",
+ "[step] 409\n",
+ "[step] 410\n",
+ "[step] 411\n",
+ "[step] 412\n",
+ "[step] 413\n",
+ "[step] 414\n",
+ "[step] 415\n",
+ "[step] 416\n",
+ "[step] 417\n",
+ "[step] 418\n",
+ "[step] 419\n",
+ "[step] 420\n",
+ "[step] 421\n",
+ "[step] 422\n",
+ "[step] 423\n",
+ "[step] 424\n",
+ "[step] 425\n",
+ "[step] 426\n",
+ "[step] 427\n",
+ "[step] 428\n",
+ "[step] 429\n",
+ "[step] 430\n",
+ "[step] 431\n",
+ "[step] 432\n",
+ "[step] 433\n",
+ "[step] 434\n",
+ "[step] 435\n",
+ "[step] 436\n",
+ "[step] 437\n",
+ "[step] 438\n",
+ "[step] 439\n",
+ "[step] 440\n",
+ "[*] Best: 58952.967129705365\n",
+ "[*] Writing the best solution to file\n",
+ "\n",
+ "[*] Running for: 21.8 seconds\n",
+ "\n",
+ "Best Fitness:\t 58952.967129705365\n",
+ "Best Solution:\t [395, 173, 172, 161, 149, 136, 126, 385, 114, 103, 440, 101, 102, 113, 125, 135, 148, 160, 171, 184, 399, 404, 226, 233, 237, 238, 265, 268, 272, 275, 278, 280, 281, 427, 341, 340, 345, 346, 347, 432, 348, 349, 350, 351, 342, 352, 353, 354, 433, 355, 356, 357, 434, 358, 359, 360, 343, 361, 362, 363, 364, 365, 366, 344, 367, 368, 369, 370, 371, 372, 373, 374, 337, 336, 426, 335, 334, 333, 306, 332, 331, 330, 305, 304, 303, 302, 301, 300, 299, 298, 297, 296, 295, 294, 293, 292, 291, 290, 289, 288, 287, 286, 285, 284, 283, 282, 279, 425, 439, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 428, 324, 325, 326, 327, 328, 329, 430, 429, 277, 416, 417, 252, 251, 250, 249, 414, 248, 247, 246, 245, 244, 243, 242, 241, 240, 239, 234, 227, 405, 400, 185, 398, 186, 174, 391, 137, 115, 388, 386, 150, 151, 392, 152, 138, 127, 116, 104, 105, 106, 117, 128, 140, 153, 164, 163, 176, 188, 200, 401, 201, 189, 190, 397, 177, 165, 154, 141, 129, 118, 107, 438, 82, 50, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 81, 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 65, 441, 98, 99, 83, 51, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 375, 376, 32, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 84, 85, 86, 377, 87, 88, 89, 90, 91, 92, 93, 94, 378, 95, 379, 96, 97, 382, 383, 112, 124, 134, 147, 159, 170, 183, 198, 209, 219, 225, 410, 409, 413, 236, 264, 419, 267, 415, 263, 262, 235, 261, 260, 259, 258, 257, 256, 255, 254, 253, 231, 223, 214, 202, 178, 394, 393, 166, 155, 142, 130, 119, 108, 384, 120, 121, 109, 131, 144, 143, 390, 156, 167, 180, 193, 204, 205, 206, 194, 195, 196, 181, 168, 157, 145, 132, 122, 110, 100, 435, 111, 123, 133, 146, 158, 169, 182, 197, 208, 218, 217, 207, 216, 403, 408, 407, 411, 412, 418, 421, 437, 422, 271, 274, 436, 431, 232, 224, 215, 203, 191, 179, 192, 389, 387, 380, 381, 139, 162, 175, 187, 199, 212, 221, 229, 228, 220, 210, 402, 211, 396, 213, 222, 230, 424, 420, 423, 339, 338, 276, 273, 270, 266, 269, 406]\n"
+ ]
+ }
+ ],
+ "source": [
+ "tsp_problem = './template/data/medium/pcb442.tsp'\n",
+ "tsp_coords = np.array(load_data(tsp_problem))\n",
+ "\n",
+ "import timeit\n",
+ "start = timeit.default_timer()\n",
+ "\n",
+ "# Your Model Running\n",
+ "\n",
+ "model = MyModel()\n",
+ "best_solution, fitness_list = TSP(tsp_problem, model)\n",
+ "\n",
+ "# Your Model End\n",
+ "\n",
+ "stop = timeit.default_timer()\n",
+ "print()\n",
+ "print('[*] Running for: {time:.1f} seconds'.format(time=(stop - start)))\n",
+ "\n",
+ "print()\n",
+ "print (\"Best Fitness:\\t\", fitness(best_solution, tsp_coords))\n",
+ "print (\"Best Solution:\\t\", best_solution)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Dynamic Programming"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Costs a lot of memory"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 90,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import math\n",
+ "import random\n",
+ "from model.base_model import Model\n",
+ "\n",
+ "class MyModel(Model):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ "\n",
+ " def init(self, coords):\n",
+ " \"\"\"\n",
+ " Put your initialization here.\n",
+ " \"\"\"\n",
+ " super().init(coords)\n",
+ " self.log(\"Nothing to initialize in your model now\")\n",
+ "\n",
+ " def getMST(self, node):\n",
+ " MST = []\n",
+ " distances = []\n",
+ " for i in range(0, self.N):\n",
+ " if i != node:\n",
+ " MST.append(i)\n",
+ " distances.append(self.dist(node, i))\n",
+ " return [x for _,x in sorted(zip(distances, MST))]\n",
+ "\n",
+ " def fit(self, max_it=1000, visualize=False):\n",
+ " \"\"\"\n",
+ " Put your iteration process here.\n",
+ " \"\"\"\n",
+ " self.log(\"Uniform Cost Search Solution\")\n",
+ "\n",
+ " UCS_solutions = []\n",
+ " UCS_losses = []\n",
+ "\n",
+ " # Depth First: Set one city as starting point, iterate to the end, then select next city as starting point.\n",
+ " MSTs = []\n",
+ " for i in range(0, self.N):\n",
+ " MSTs.append([-1] * self.N)\n",
+ " for i in range(0, self.N):\n",
+ " solution = []\n",
+ " solution.append(i)\n",
+ " unvisited_list = list(range(0, self.N))\n",
+ " cur_city = i\n",
+ " print(\"[starting]\", i)\n",
+ " for steps in range(self.N - 1):\n",
+ " # print(unvisited_list)\n",
+ " unvisited_list.remove(cur_city)\n",
+ " if MSTs[cur_city][0] == -1:\n",
+ " MST = self.getMST(cur_city)\n",
+ " MSTs[cur_city] = MST\n",
+ " \n",
+ " for j in MSTs[cur_city]:\n",
+ " if(j in unvisited_list):\n",
+ " solution.append(j)\n",
+ " cur_city = j\n",
+ " break\n",
+ " # print(solution)\n",
+ " UCS_solutions.append(solution)\n",
+ " UCS_losses.append(self.fitness(solution))\n",
+ "\n",
+ " self.best_solution = UCS_solutions[ UCS_losses.index(min(UCS_losses)) ]\n",
+ " self.fitness_list.append(self.fitness(self.best_solution))\n",
+ "\n",
+ " return self.best_solution, self.fitness_list"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 91,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[MyModel] Nothing to initialize in your model now\n",
+ "[MyModel] Uniform Cost Search Solution\n",
+ "[starting] 0\n",
+ "[starting] 1\n",
+ "[starting] 2\n",
+ "[starting] 3\n",
+ "[starting] 4\n",
+ "[starting] 5\n",
+ "[starting] 6\n",
+ "[starting] 7\n",
+ "[starting] 8\n",
+ "[starting] 9\n",
+ "[starting] 10\n",
+ "[starting] 11\n",
+ "[starting] 12\n",
+ "[starting] 13\n",
+ "[starting] 14\n",
+ "[starting] 15\n",
+ "[starting] 16\n",
+ "[starting] 17\n",
+ "[starting] 18\n",
+ "[starting] 19\n",
+ "[starting] 20\n",
+ "[starting] 21\n",
+ "[starting] 22\n",
+ "[starting] 23\n",
+ "[starting] 24\n",
+ "[starting] 25\n",
+ "[starting] 26\n",
+ "[starting] 27\n",
+ "[starting] 28\n",
+ "[starting] 29\n",
+ "[starting] 30\n",
+ "[starting] 31\n",
+ "[starting] 32\n",
+ "[starting] 33\n",
+ "[starting] 34\n",
+ "[starting] 35\n",
+ "[starting] 36\n",
+ "[starting] 37\n",
+ "[starting] 38\n",
+ "[starting] 39\n",
+ "[starting] 40\n",
+ "[starting] 41\n",
+ "[starting] 42\n",
+ "[starting] 43\n",
+ "[starting] 44\n",
+ "[starting] 45\n",
+ "[starting] 46\n",
+ "[starting] 47\n",
+ "[starting] 48\n",
+ "[starting] 49\n",
+ "[starting] 50\n",
+ "[starting] 51\n",
+ "[starting] 52\n",
+ "[starting] 53\n",
+ "[starting] 54\n",
+ "[starting] 55\n",
+ "[starting] 56\n",
+ "[starting] 57\n",
+ "[starting] 58\n",
+ "[starting] 59\n",
+ "[starting] 60\n",
+ "[starting] 61\n",
+ "[starting] 62\n",
+ "[starting] 63\n",
+ "[starting] 64\n",
+ "[starting] 65\n",
+ "[starting] 66\n",
+ "[starting] 67\n",
+ "[starting] 68\n",
+ "[starting] 69\n",
+ "[starting] 70\n",
+ "[starting] 71\n",
+ "[starting] 72\n",
+ "[starting] 73\n",
+ "[starting] 74\n",
+ "[starting] 75\n",
+ "[starting] 76\n",
+ "[starting] 77\n",
+ "[starting] 78\n",
+ "[starting] 79\n",
+ "[starting] 80\n",
+ "[starting] 81\n",
+ "[starting] 82\n",
+ "[starting] 83\n",
+ "[starting] 84\n",
+ "[starting] 85\n",
+ "[starting] 86\n",
+ "[starting] 87\n",
+ "[starting] 88\n",
+ "[starting] 89\n",
+ "[starting] 90\n",
+ "[starting] 91\n",
+ "[starting] 92\n",
+ "[starting] 93\n",
+ "[starting] 94\n",
+ "[starting] 95\n",
+ "[starting] 96\n",
+ "[starting] 97\n",
+ "[starting] 98\n",
+ "[starting] 99\n",
+ "[starting] 100\n",
+ "[starting] 101\n",
+ "[starting] 102\n",
+ "[starting] 103\n",
+ "[starting] 104\n",
+ "[starting] 105\n",
+ "[starting] 106\n",
+ "[starting] 107\n",
+ "[starting] 108\n",
+ "[starting] 109\n",
+ "[starting] 110\n",
+ "[starting] 111\n",
+ "[starting] 112\n",
+ "[starting] 113\n",
+ "[starting] 114\n",
+ "[starting] 115\n",
+ "[starting] 116\n",
+ "[starting] 117\n",
+ "[starting] 118\n",
+ "[starting] 119\n",
+ "[starting] 120\n",
+ "[starting] 121\n",
+ "[starting] 122\n",
+ "[starting] 123\n",
+ "[starting] 124\n",
+ "[starting] 125\n",
+ "[starting] 126\n",
+ "[starting] 127\n",
+ "[starting] 128\n",
+ "[starting] 129\n",
+ "[starting] 130\n",
+ "[starting] 131\n",
+ "[starting] 132\n",
+ "[starting] 133\n",
+ "[starting] 134\n",
+ "[starting] 135\n",
+ "[starting] 136\n",
+ "[starting] 137\n",
+ "[starting] 138\n",
+ "[starting] 139\n",
+ "[starting] 140\n",
+ "[starting] 141\n",
+ "[starting] 142\n",
+ "[starting] 143\n",
+ "[starting] 144\n",
+ "[starting] 145\n",
+ "[starting] 146\n",
+ "[starting] 147\n",
+ "[starting] 148\n",
+ "[starting] 149\n",
+ "[starting] 150\n",
+ "[starting] 151\n",
+ "[starting] 152\n",
+ "[starting] 153\n",
+ "[starting] 154\n",
+ "[starting] 155\n",
+ "[starting] 156\n",
+ "[starting] 157\n",
+ "[starting] 158\n",
+ "[starting] 159\n",
+ "[starting] 160\n",
+ "[starting] 161\n",
+ "[starting] 162\n",
+ "[starting] 163\n",
+ "[starting] 164\n",
+ "[starting] 165\n",
+ "[starting] 166\n",
+ "[starting] 167\n",
+ "[starting] 168\n",
+ "[starting] 169\n",
+ "[starting] 170\n",
+ "[starting] 171\n",
+ "[starting] 172\n",
+ "[starting] 173\n",
+ "[starting] 174\n",
+ "[starting] 175\n",
+ "[starting] 176\n",
+ "[starting] 177\n",
+ "[starting] 178\n",
+ "[starting] 179\n",
+ "[starting] 180\n",
+ "[starting] 181\n",
+ "[starting] 182\n",
+ "[starting] 183\n",
+ "[starting] 184\n",
+ "[starting] 185\n",
+ "[starting] 186\n",
+ "[starting] 187\n",
+ "[starting] 188\n",
+ "[starting] 189\n",
+ "[starting] 190\n",
+ "[starting] 191\n",
+ "[starting] 192\n",
+ "[starting] 193\n",
+ "[starting] 194\n",
+ "[starting] 195\n",
+ "[starting] 196\n",
+ "[starting] 197\n",
+ "[starting] 198\n",
+ "[starting] 199\n",
+ "[starting] 200\n",
+ "[starting] 201\n",
+ "[starting] 202\n",
+ "[starting] 203\n",
+ "[starting] 204\n",
+ "[starting] 205\n",
+ "[starting] 206\n",
+ "[starting] 207\n",
+ "[starting] 208\n",
+ "[starting] 209\n",
+ "[starting] 210\n",
+ "[starting] 211\n",
+ "[starting] 212\n",
+ "[starting] 213\n",
+ "[starting] 214\n",
+ "[starting] 215\n",
+ "[starting] 216\n",
+ "[starting] 217\n",
+ "[starting] 218\n",
+ "[starting] 219\n",
+ "[starting] 220\n",
+ "[starting] 221\n",
+ "[starting] 222\n",
+ "[starting] 223\n",
+ "[starting] 224\n",
+ "[starting] 225\n",
+ "[starting] 226\n",
+ "[starting] 227\n",
+ "[starting] 228\n",
+ "[starting] 229\n",
+ "[starting] 230\n",
+ "[starting] 231\n",
+ "[starting] 232\n",
+ "[starting] 233\n",
+ "[starting] 234\n",
+ "[starting] 235\n",
+ "[starting] 236\n",
+ "[starting] 237\n",
+ "[starting] 238\n",
+ "[starting] 239\n",
+ "[starting] 240\n",
+ "[starting] 241\n",
+ "[starting] 242\n",
+ "[starting] 243\n",
+ "[starting] 244\n",
+ "[starting] 245\n",
+ "[starting] 246\n",
+ "[starting] 247\n",
+ "[starting] 248\n",
+ "[starting] 249\n",
+ "[starting] 250\n",
+ "[starting] 251\n",
+ "[starting] 252\n",
+ "[starting] 253\n",
+ "[starting] 254\n",
+ "[starting] 255\n",
+ "[starting] 256\n",
+ "[starting] 257\n",
+ "[starting] 258\n",
+ "[starting] 259\n",
+ "[starting] 260\n",
+ "[starting] 261\n",
+ "[starting] 262\n",
+ "[starting] 263\n",
+ "[starting] 264\n",
+ "[starting] 265\n",
+ "[starting] 266\n",
+ "[starting] 267\n",
+ "[starting] 268\n",
+ "[starting] 269\n",
+ "[starting] 270\n",
+ "[starting] 271\n",
+ "[starting] 272\n",
+ "[starting] 273\n",
+ "[starting] 274\n",
+ "[starting] 275\n",
+ "[starting] 276\n",
+ "[starting] 277\n",
+ "[starting] 278\n",
+ "[starting] 279\n",
+ "[starting] 280\n",
+ "[starting] 281\n",
+ "[starting] 282\n",
+ "[starting] 283\n",
+ "[starting] 284\n",
+ "[starting] 285\n",
+ "[starting] 286\n",
+ "[starting] 287\n",
+ "[starting] 288\n",
+ "[starting] 289\n",
+ "[starting] 290\n",
+ "[starting] 291\n",
+ "[starting] 292\n",
+ "[starting] 293\n",
+ "[starting] 294\n",
+ "[starting] 295\n",
+ "[starting] 296\n",
+ "[starting] 297\n",
+ "[starting] 298\n",
+ "[starting] 299\n",
+ "[starting] 300\n",
+ "[starting] 301\n",
+ "[starting] 302\n",
+ "[starting] 303\n",
+ "[starting] 304\n",
+ "[starting] 305\n",
+ "[starting] 306\n",
+ "[starting] 307\n",
+ "[starting] 308\n",
+ "[starting] 309\n",
+ "[starting] 310\n",
+ "[starting] 311\n",
+ "[starting] 312\n",
+ "[starting] 313\n",
+ "[starting] 314\n",
+ "[starting] 315\n",
+ "[starting] 316\n",
+ "[starting] 317\n",
+ "[starting] 318\n",
+ "[starting] 319\n",
+ "[starting] 320\n",
+ "[starting] 321\n",
+ "[starting] 322\n",
+ "[starting] 323\n",
+ "[starting] 324\n",
+ "[starting] 325\n",
+ "[starting] 326\n",
+ "[starting] 327\n",
+ "[starting] 328\n",
+ "[starting] 329\n",
+ "[starting] 330\n",
+ "[starting] 331\n",
+ "[starting] 332\n",
+ "[starting] 333\n",
+ "[starting] 334\n",
+ "[starting] 335\n",
+ "[starting] 336\n",
+ "[starting] 337\n",
+ "[starting] 338\n",
+ "[starting] 339\n",
+ "[starting] 340\n",
+ "[starting] 341\n",
+ "[starting] 342\n",
+ "[starting] 343\n",
+ "[starting] 344\n",
+ "[starting] 345\n",
+ "[starting] 346\n",
+ "[starting] 347\n",
+ "[starting] 348\n",
+ "[starting] 349\n",
+ "[starting] 350\n",
+ "[starting] 351\n",
+ "[starting] 352\n",
+ "[starting] 353\n",
+ "[starting] 354\n",
+ "[starting] 355\n",
+ "[starting] 356\n",
+ "[starting] 357\n",
+ "[starting] 358\n",
+ "[starting] 359\n",
+ "[starting] 360\n",
+ "[starting] 361\n",
+ "[starting] 362\n",
+ "[starting] 363\n",
+ "[starting] 364\n",
+ "[starting] 365\n",
+ "[starting] 366\n",
+ "[starting] 367\n",
+ "[starting] 368\n",
+ "[starting] 369\n",
+ "[starting] 370\n",
+ "[starting] 371\n",
+ "[starting] 372\n",
+ "[starting] 373\n",
+ "[starting] 374\n",
+ "[starting] 375\n",
+ "[starting] 376\n",
+ "[starting] 377\n",
+ "[starting] 378\n",
+ "[starting] 379\n",
+ "[starting] 380\n",
+ "[starting] 381\n",
+ "[starting] 382\n",
+ "[starting] 383\n",
+ "[starting] 384\n",
+ "[starting] 385\n",
+ "[starting] 386\n",
+ "[starting] 387\n",
+ "[starting] 388\n",
+ "[starting] 389\n",
+ "[starting] 390\n",
+ "[starting] 391\n",
+ "[starting] 392\n",
+ "[starting] 393\n",
+ "[starting] 394\n",
+ "[starting] 395\n",
+ "[starting] 396\n",
+ "[starting] 397\n",
+ "[starting] 398\n",
+ "[starting] 399\n",
+ "[starting] 400\n",
+ "[starting] 401\n",
+ "[starting] 402\n",
+ "[starting] 403\n",
+ "[starting] 404\n",
+ "[starting] 405\n",
+ "[starting] 406\n",
+ "[starting] 407\n",
+ "[starting] 408\n",
+ "[starting] 409\n",
+ "[starting] 410\n",
+ "[starting] 411\n",
+ "[starting] 412\n",
+ "[starting] 413\n",
+ "[starting] 414\n",
+ "[starting] 415\n",
+ "[starting] 416\n",
+ "[starting] 417\n",
+ "[starting] 418\n",
+ "[starting] 419\n",
+ "[starting] 420\n",
+ "[starting] 421\n",
+ "[starting] 422\n",
+ "[starting] 423\n",
+ "[starting] 424\n",
+ "[starting] 425\n",
+ "[starting] 426\n",
+ "[starting] 427\n",
+ "[starting] 428\n",
+ "[starting] 429\n",
+ "[starting] 430\n",
+ "[starting] 431\n",
+ "[starting] 432\n",
+ "[starting] 433\n",
+ "[starting] 434\n",
+ "[starting] 435\n",
+ "[starting] 436\n",
+ "[starting] 437\n",
+ "[starting] 438\n",
+ "[starting] 439\n",
+ "[starting] 440\n",
+ "[starting] 441\n",
+ "[*] Best: 58952.967129705365\n",
+ "[*] Writing the best solution to file\n",
+ "\n",
+ "[*] Running for: 1.3 seconds\n",
+ "\n",
+ "Best Fitness:\t 58952.967129705365\n",
+ "Best Solution:\t [395, 173, 172, 161, 149, 136, 126, 385, 114, 103, 440, 101, 102, 113, 125, 135, 148, 160, 171, 184, 399, 404, 226, 233, 237, 238, 265, 268, 272, 275, 278, 280, 281, 427, 341, 340, 345, 346, 347, 432, 348, 349, 350, 351, 342, 352, 353, 354, 433, 355, 356, 357, 434, 358, 359, 360, 343, 361, 362, 363, 364, 365, 366, 344, 367, 368, 369, 370, 371, 372, 373, 374, 337, 336, 426, 335, 334, 333, 306, 332, 331, 330, 305, 304, 303, 302, 301, 300, 299, 298, 297, 296, 295, 294, 293, 292, 291, 290, 289, 288, 287, 286, 285, 284, 283, 282, 279, 425, 439, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 428, 324, 325, 326, 327, 328, 329, 430, 429, 277, 416, 417, 252, 251, 250, 249, 414, 248, 247, 246, 245, 244, 243, 242, 241, 240, 239, 234, 227, 405, 400, 185, 398, 186, 174, 391, 137, 115, 388, 386, 150, 151, 392, 152, 138, 127, 116, 104, 105, 106, 117, 128, 140, 153, 164, 163, 176, 188, 200, 401, 201, 189, 190, 397, 177, 165, 154, 141, 129, 118, 107, 438, 82, 50, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 81, 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 65, 441, 98, 99, 83, 51, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 375, 376, 32, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 84, 85, 86, 377, 87, 88, 89, 90, 91, 92, 93, 94, 378, 95, 379, 96, 97, 382, 383, 112, 124, 134, 147, 159, 170, 183, 198, 209, 219, 225, 410, 409, 413, 236, 264, 419, 267, 415, 263, 262, 235, 261, 260, 259, 258, 257, 256, 255, 254, 253, 231, 223, 214, 202, 178, 394, 393, 166, 155, 142, 130, 119, 108, 384, 120, 121, 109, 131, 144, 143, 390, 156, 167, 180, 193, 204, 205, 206, 194, 195, 196, 181, 168, 157, 145, 132, 122, 110, 100, 435, 111, 123, 133, 146, 158, 169, 182, 197, 208, 218, 217, 207, 216, 403, 408, 407, 411, 412, 418, 421, 437, 422, 271, 274, 436, 431, 232, 224, 215, 203, 191, 179, 192, 389, 387, 380, 381, 139, 162, 175, 187, 199, 212, 221, 229, 228, 220, 210, 402, 211, 396, 213, 222, 230, 424, 420, 423, 339, 338, 276, 273, 270, 266, 269, 406]\n"
+ ]
+ }
+ ],
+ "source": [
+ "tsp_problem = './template/data/medium/pcb442.tsp'\n",
+ "tsp_coords = np.array(load_data(tsp_problem))\n",
+ "\n",
+ "import timeit\n",
+ "start = timeit.default_timer()\n",
+ "\n",
+ "# Your Model Running\n",
+ "\n",
+ "model = MyModel()\n",
+ "best_solution, fitness_list = TSP(tsp_problem, model)\n",
+ "\n",
+ "# Your Model End\n",
+ "\n",
+ "stop = timeit.default_timer()\n",
+ "print()\n",
+ "print('[*] Running for: {time:.1f} seconds'.format(time=(stop - start)))\n",
+ "\n",
+ "print()\n",
+ "print (\"Best Fitness:\\t\", fitness(best_solution, tsp_coords))\n",
+ "print (\"Best Solution:\\t\", best_solution)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Your Smart Model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import math\n",
+ "import random\n",
+ "from model.base_model import Model\n",
+ "\n",
+ "class MyModel(Model):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ "\n",
+ " def init(self, coords):\n",
+ " \"\"\"\n",
+ " Put your initialization here.\n",
+ " \"\"\"\n",
+ " super().init(coords)\n",
+ " self.log(\"Nothing to initialize in your model now\")\n",
+ "\n",
+ " def fit(self, max_it=1000, visualize=False):\n",
+ " \"\"\"\n",
+ " Put your iteration process here.\n",
+ " \"\"\"\n",
+ " self.log(\"Naive Random Solution\")\n",
+ " self.best_solution = np.random.permutation(self.N).tolist()\n",
+ " self.fitness_list.append(self.fitness(self.best_solution))\n",
+ "\n",
+ " return self.best_solution, self.fitness_list"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Simulated Annealing"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import math\n",
+ "import random\n",
+ "from model.base_model import Model\n",
+ "\n",
+ "class MyModel(Model):\n",
+ " def __init__(self, T=-1, alpha=-1, stopping_T=-1):\n",
+ " super().__init__()\n",
+ "\n",
+ " self.iteration = 0\n",
+ "\n",
+ " self.T = T\n",
+ " self.alpha = 0.995 if alpha == -1 else alpha\n",
+ " self.stopping_temperature = 1e-8 if stopping_T == -1 else stopping_T\n",
+ "\n",
+ " def init(self, coords):\n",
+ " super().init(coords)\n",
+ "\n",
+ " if (self.T == -1):\n",
+ " self.T = math.sqrt(self.N) \n",
+ " self.T_save = self.T # save inital T to reset if batch annealing is used\n",
+ "\n",
+ " def initial_solution(self):\n",
+ " \"\"\"\n",
+ " Greedy algorithm to get an initial solution (closest-neighbour).\n",
+ " \"\"\"\n",
+ " cur_node = random.choice(self.nodes) # start from a random node\n",
+ " solution = [cur_node]\n",
+ "\n",
+ " free_nodes = set(self.nodes)\n",
+ " free_nodes.remove(cur_node)\n",
+ " while free_nodes:\n",
+ " next_node = min(free_nodes, key=lambda x: self.dist(cur_node, x)) # nearest neighbour\n",
+ " free_nodes.remove(next_node)\n",
+ " solution.append(next_node)\n",
+ " cur_node = next_node\n",
+ "\n",
+ " cur_fit = self.fitness(solution)\n",
+ " if cur_fit < self.best_fitness: # If best found so far, update best fitness\n",
+ " self.best_fitness = cur_fit\n",
+ " self.best_solution = solution\n",
+ " self.fitness_list.append(cur_fit)\n",
+ " return solution, cur_fit\n",
+ "\n",
+ " def p_accept(self, candidate_fitness):\n",
+ " \"\"\"\n",
+ " Probability of accepting if the candidate is worse than current.\n",
+ " Depends on the current temperature and difference between candidate and current.\n",
+ " \"\"\"\n",
+ " return math.exp(-abs(candidate_fitness - self.cur_fitness) / self.T)\n",
+ "\n",
+ " def accept(self, candidate):\n",
+ " \"\"\"\n",
+ " Accept with probability 1 if candidate is better than current.\n",
+ " Accept with probabilty p_accept(..) if candidate is worse.\n",
+ " \"\"\"\n",
+ " candidate_fitness = self.fitness(candidate)\n",
+ " if candidate_fitness < self.cur_fitness:\n",
+ " self.cur_fitness, self.cur_solution = candidate_fitness, candidate\n",
+ " if candidate_fitness < self.best_fitness:\n",
+ " self.best_fitness, self.best_solution = candidate_fitness, candidate\n",
+ " else:\n",
+ " if random.random() < self.p_accept(candidate_fitness):\n",
+ " self.cur_fitness, self.cur_solution = candidate_fitness, candidate\n",
+ "\n",
+ " def fit(self, max_it=1000):\n",
+ " \"\"\"\n",
+ " Execute simulated annealing algorithm.\n",
+ " \"\"\"\n",
+ " # Initialize with the greedy solution.\n",
+ " self.cur_solution, self.cur_fitness = self.initial_solution()\n",
+ "\n",
+ " self.log(\"Starting annealing.\")\n",
+ " while self.T >= self.stopping_temperature and self.iteration < max_it:\n",
+ " candidate = list(self.cur_solution)\n",
+ " l = random.randint(1, self.N - 1)\n",
+ " i = random.randint(0, self.N - l)\n",
+ " candidate[i : (i + l)] = reversed(candidate[i : (i + l)])\n",
+ " self.accept(candidate)\n",
+ " self.T *= self.alpha\n",
+ " self.iteration += 1\n",
+ "\n",
+ " self.fitness_list.append(self.cur_fitness)\n",
+ "\n",
+ " self.log(f\"Best fitness obtained: {self.best_fitness}\")\n",
+ " improvement = 100 * (self.fitness_list[0] - self.best_fitness) / (self.fitness_list[0])\n",
+ " self.log(f\"Improvement over greedy heuristic: {improvement : .2f}%\")\n",
+ "\n",
+ " return self.best_solution, self.fitness_list"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Test your Model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tsp_problem = './template/data/simple/ulysses16.tsp'\n",
+ "tsp_coords = np.array(load_data(tsp_problem))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "import timeit\n",
+ "start = timeit.default_timer()\n",
+ "\n",
+ "# Your Model Running\n",
+ "\n",
+ "model = MyModel()\n",
+ "best_solution, fitness_list = TSP(tsp_problem, model)\n",
+ "\n",
+ "# Your Model End\n",
+ "\n",
+ "stop = timeit.default_timer()\n",
+ "print()\n",
+ "print('[*] Running for: {time:.1f} seconds'.format(time=(stop - start)))\n",
+ "\n",
+ "print()\n",
+ "print (\"Best Fitness:\\t\", fitness(best_solution, tsp_coords))\n",
+ "print (\"Best Solution:\\t\", best_solution)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Test All Dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 83,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "./template/data/medium/pcb442.tsp\n",
+ "./template/data/medium/a280.tsp\n",
+ "./template/data/hard/dsj1000.tsp\n",
+ "./template/data/simple/att48.tsp\n",
+ "./template/data/simple/ulysses16.tsp\n",
+ "./template/data/simple/st70.tsp\n"
+ ]
+ }
+ ],
+ "source": [
+ "for root, _, files in os.walk('./template/data'):\n",
+ " if(files):\n",
+ " for f in files:\n",
+ " print(str(root) + \"/\" + f)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for root, _, files in os.walk('./template/data'):\n",
+ " if(files):\n",
+ " for f in files:\n",
+ " # Get input file name\n",
+ " tsp_file = str(root) + '/' + str(f)\n",
+ " log(tsp_file)\n",
+ "\n",
+ " # Your Model\n",
+ " model = MyModel()\n",
+ "\n",
+ " # Run TSP\n",
+ " TSP(tsp_file, model)\n",
+ "\n",
+ " print()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "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.5"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/Workshop - 6 (GA, SOM).ipynb b/Workshop - 6 (GA, SOM).ipynb
new file mode 100644
index 0000000..022f6c2
--- /dev/null
+++ b/Workshop - 6 (GA, SOM).ipynb
@@ -0,0 +1,1317 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Make sure you run this at the begining**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import sys\n",
+ "import math\n",
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "# Append template path to sys path\n",
+ "sys.path.append(os.getcwd() + \"/template\") "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from utils.load_data import load_data\n",
+ "from utils.load_data import log\n",
+ "from utils.visualize_tsp import plotTSP\n",
+ "from utils.tsp import TSP\n",
+ "from utils.tsp import TSP_Bench\n",
+ "from utils.tsp import TSP_Bench_ALL"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Workshop Starts Here"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Get familiar with your dataset"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "There are problems at different levels. **3 simple, 2 medium, 1 hard**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "scrolled": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "./template/data/medium/pcb442.tsp\n",
+ "./template/data/medium/a280.tsp\n",
+ "./template/data/hard/dsj1000.tsp\n",
+ "./template/data/simple/att48.tsp\n",
+ "./template/data/simple/ulysses16.tsp\n",
+ "./template/data/simple/st70.tsp\n"
+ ]
+ }
+ ],
+ "source": [
+ "for root, _, files in os.walk('./template/data'):\n",
+ " if(files):\n",
+ " for f in files:\n",
+ " print(str(root) + \"/\" + f)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ulysses16 = np.array(load_data(\"./template/data/simple/ulysses16.tsp\"))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[38.24, 20.42],\n",
+ " [39.57, 26.15],\n",
+ " [40.56, 25.32],\n",
+ " [36.26, 23.12],\n",
+ " [33.48, 10.54],\n",
+ " [37.56, 12.19],\n",
+ " [38.42, 13.11],\n",
+ " [37.52, 20.44],\n",
+ " [41.23, 9.1 ],\n",
+ " [41.17, 13.05],\n",
+ " [36.08, -5.21],\n",
+ " [38.47, 15.13],\n",
+ " [38.15, 15.35],\n",
+ " [37.51, 15.17],\n",
+ " [35.49, 14.32],\n",
+ " [39.36, 19.56]])"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "ulysses16[:]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.scatter(ulysses16[:, 0], ulysses16[:, 1])\n",
+ "for i in range(0, 16):\n",
+ " plt.annotate(i, (ulysses16[i, 0], ulysses16[i, 1]+0.5))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Naive Solution: In Order"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]\n"
+ ]
+ }
+ ],
+ "source": [
+ "simple_sequence = list(range(0, 16))\n",
+ "print(simple_sequence)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plotTSP([simple_sequence], ulysses16, num_iters=1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Naive Solution: Random Permutation"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[1, 8, 9, 12, 3, 2, 6, 11, 0, 14, 15, 7, 4, 5, 13, 10]\n"
+ ]
+ }
+ ],
+ "source": [
+ "random_permutation = np.random.permutation(16).tolist()\n",
+ "print(random_permutation)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plotTSP([random_permutation], ulysses16, num_iters=1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Best Solution"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "best_ulysses16 = [0, 13, 12, 11, 6, 5, 14, 4, 10, 8, 9, 15, 2, 1, 3, 7]\n",
+ "plotTSP([best_ulysses16], ulysses16, num_iters=1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Calculate Fitness (Sum of all Distances)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def dist(node_0, node_1, coords):\n",
+ " \"\"\"\n",
+ " Euclidean distance between two nodes.\n",
+ " \"\"\"\n",
+ " coord_0, coord_1 = coords[node_0], coords[node_1]\n",
+ " return math.sqrt((coord_0[0] - coord_1[0]) ** 2 + (coord_0[1] - coord_1[1]) ** 2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Coordinate of City 0: [38.24 20.42]\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Coordinate of City 0:\", ulysses16[0])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Coordinate of City 1: [39.57 26.15]\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Coordinate of City 1:\", ulysses16[1])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Distance Between 5.882329470541408\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Distance Between\", dist(0, 1, ulysses16))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def fitness(solution, coords):\n",
+ " N = len(coords)\n",
+ " cur_fit = 0\n",
+ " for i in range(len(solution)):\n",
+ " cur_fit += dist(solution[i % N], solution[(i + 1) % N], coords)\n",
+ " return cur_fit"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Order Fitness:\t 104.42225210207233\n",
+ "Random Fitness:\t 142.71833065004333\n",
+ "Best Fitness:\t 74.10873595815309\n"
+ ]
+ }
+ ],
+ "source": [
+ "print (\"Order Fitness:\\t\", fitness(simple_sequence, ulysses16))\n",
+ "print (\"Random Fitness:\\t\", fitness(random_permutation, ulysses16))\n",
+ "print (\"Best Fitness:\\t\", fitness(best_ulysses16, ulysses16))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Naive Random Model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import math\n",
+ "import random\n",
+ "from model.base_model import Model\n",
+ "\n",
+ "class MyRandomModel(Model):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ "\n",
+ " def init(self, nodes):\n",
+ " \"\"\"\n",
+ " Put your initialization here.\n",
+ " \"\"\"\n",
+ " super().init(nodes)\n",
+ "\n",
+ " def fit(self, max_it):\n",
+ " \"\"\"\n",
+ " Put your iteration process here.\n",
+ " \"\"\"\n",
+ " random_solutions = []\n",
+ " for i in range(0, max_it):\n",
+ " solution = np.random.permutation(self.N).tolist()\n",
+ " random_solutions.append(solution)\n",
+ " self.fitness_list.append(self.fitness(solution))\n",
+ "\n",
+ " self.best_solution = random_solutions[self.fitness_list.index(min(self.fitness_list))]\n",
+ " return self.best_solution, self.fitness_list"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tsp_file = './template/data/simple/ulysses16.tsp'"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[*] [Node] 16, [Best] 108.63032651658955\n",
+ "[*] Running for: 0.01 seconds\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = MyRandomModel()\n",
+ "best_solution, fitness_list, time = TSP_Bench(tsp_file, model, max_it=100)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[]"
+ ]
+ },
+ "execution_count": 21,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.plot(fitness_list, 'o-')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Genetic Algorithm"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 244,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class Gene: # City\n",
+ " def __init__(self, name, lat, lng):\n",
+ " self.name = name\n",
+ " self.lat = lat\n",
+ " self.lng = lng\n",
+ "\n",
+ " def get_distance_to(self, dest):\n",
+ " return math.sqrt( (self.lng - dest.lng) ** 2 + (self.lat - dest.lat) ** 2 )\n",
+ "\n",
+ "class Individual: # Route: possible solution to TSP\n",
+ " def __init__(self, genes):\n",
+ " assert(len(genes) > 3)\n",
+ " self.genes = genes\n",
+ " self.__reset_params()\n",
+ "\n",
+ " def swap(self, gene_1, gene_2):\n",
+ " self.genes[0]\n",
+ " a, b = self.genes.index(gene_1), self.genes.index(gene_2)\n",
+ " self.genes[b], self.genes[a] = self.genes[a], self.genes[b]\n",
+ " self.__reset_params()\n",
+ "\n",
+ " def add(self, gene):\n",
+ " self.genes.append(gene)\n",
+ " self.__reset_params()\n",
+ "\n",
+ " @property\n",
+ " def fitness(self):\n",
+ " if self.__fitness == 0:\n",
+ " self.__fitness = 1 / self.travel_cost # Normalize travel cost\n",
+ " return self.__fitness\n",
+ "\n",
+ " @property\n",
+ " def travel_cost(self): # Get total travelling cost\n",
+ " if self.__travel_cost == 0:\n",
+ " for i in range(len(self.genes)):\n",
+ " origin = self.genes[i]\n",
+ " if i == len(self.genes) - 1:\n",
+ " dest = self.genes[0]\n",
+ " else:\n",
+ " dest = self.genes[i+1]\n",
+ "\n",
+ " self.__travel_cost += origin.get_distance_to(dest)\n",
+ "\n",
+ " return self.__travel_cost\n",
+ "\n",
+ " def __reset_params(self):\n",
+ " self.__travel_cost = 0\n",
+ " self.__fitness = 0\n",
+ "\n",
+ "class Population: # Population of individuals\n",
+ " def __init__(self, individuals):\n",
+ " self.individuals = individuals\n",
+ "\n",
+ " @staticmethod\n",
+ " def gen_individuals(sz, genes):\n",
+ " individuals = []\n",
+ " for _ in range(sz):\n",
+ " individuals.append(Individual(sample(genes, len(genes))))\n",
+ " return Population(individuals)\n",
+ "\n",
+ " def add(self, route):\n",
+ " self.individuals.append(route)\n",
+ "\n",
+ " def rmv(self, route):\n",
+ " self.individuals.remove(route)\n",
+ "\n",
+ " def get_fittest(self):\n",
+ " fittest = self.individuals[0]\n",
+ " for route in self.individuals:\n",
+ " if route.fitness > fittest.fitness:\n",
+ " fittest = route\n",
+ "\n",
+ " return fittest"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 380,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import math\n",
+ "import random\n",
+ "from model.base_model import Model\n",
+ "from random import randint, sample\n",
+ "\n",
+ "class MyGAModel(Model):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ " self.iteration = 0\n",
+ "\n",
+ " def init(self, nodes):\n",
+ " super().init(nodes)\n",
+ "\n",
+ " def evolve(self, pop, tourn_size, mut_rate):\n",
+ " new_generation = Population([])\n",
+ " pop_size = len(pop.individuals)\n",
+ " elitism_num = pop_size // 4\n",
+ "\n",
+ " # Elitism\n",
+ " for _ in range(elitism_num):\n",
+ " fittest = pop.get_fittest()\n",
+ " new_generation.add(fittest)\n",
+ " pop.rmv(fittest)\n",
+ "\n",
+ " # Crossover\n",
+ " for _ in range(elitism_num, pop_size):\n",
+ " parent_1 = self.selection(new_generation, tourn_size)\n",
+ " parent_2 = self.selection(new_generation, tourn_size)\n",
+ " child = self.crossover(parent_1, parent_2)\n",
+ " new_generation.add(child)\n",
+ "\n",
+ " # Mutation\n",
+ " for i in range(elitism_num, pop_size):\n",
+ " self.mutate(new_generation.individuals[i], mut_rate)\n",
+ "\n",
+ " return new_generation\n",
+ "\n",
+ " def crossover(self, parent_1, parent_2):\n",
+ " def fill_with_parent1_genes(child, parent, genes_n):\n",
+ " start_at = randint(0, len(parent.genes)-genes_n-1)\n",
+ " finish_at = start_at + genes_n\n",
+ " for i in range(start_at, finish_at):\n",
+ " child.genes[i] = parent_1.genes[i]\n",
+ "\n",
+ " def fill_with_parent2_genes(child, parent):\n",
+ " j = 0\n",
+ " for i in range(0, len(parent.genes)):\n",
+ " if child.genes[i] == None:\n",
+ " while parent.genes[j] in child.genes:\n",
+ " j += 1\n",
+ " child.genes[i] = parent.genes[j]\n",
+ " j += 1\n",
+ "\n",
+ " genes_n = len(parent_1.genes)\n",
+ " child = Individual([None for _ in range(genes_n)])\n",
+ " fill_with_parent1_genes(child, parent_1, genes_n // 2)\n",
+ " fill_with_parent2_genes(child, parent_2)\n",
+ "\n",
+ " return child\n",
+ "\n",
+ " def mutate(self, individual, rate):\n",
+ " for _ in range(len(individual.genes)):\n",
+ " if random.random() < rate:\n",
+ " sel_genes = sample(individual.genes, 2)\n",
+ " individual.swap(sel_genes[0], sel_genes[1])\n",
+ "\n",
+ " def selection(self, population, competitors_n):\n",
+ " return Population(sample(population.individuals, competitors_n)).get_fittest()\n",
+ "\n",
+ " def fit(self, max_it=20):\n",
+ " \"\"\"\n",
+ " Execute simulated annealing algorithm.\n",
+ " \"\"\"\n",
+ " pop_size = 1000\n",
+ " mut_rate = 0.9\n",
+ " tourn_size = 100\n",
+ "\n",
+ " genes = [Gene(num, city[0], city[1]) for num, city in enumerate(self.coords)]\n",
+ " self.genes = genes\n",
+ "\n",
+ " population = Population.gen_individuals(pop_size, genes)\n",
+ " \n",
+ "\n",
+ " for it in range(0, max_it):\n",
+ " mut_rate = mut_rate * 0.95\n",
+ " if mut_rate < 0.05:\n",
+ " mut_rate = 0.05\n",
+ " population = self.evolve(population, tourn_size, mut_rate)\n",
+ " cost = population.get_fittest().travel_cost\n",
+ "\n",
+ " it += 1\n",
+ " self.fitness_list.append(cost)\n",
+ " print(\"[step] \", it, \" [mut] \", mut_rate, \" [best] \", self.fitness_list[self.fitness_list.index(min(self.fitness_list))])\n",
+ "\n",
+ " self.best_solution = [gene.name for gene in population.get_fittest().genes]\n",
+ "\n",
+ " return self.best_solution, self.fitness_list"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 381,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tsp_problem = \"./template/data/simple/ulysses16.tsp\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 382,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Genetic Algorithm\n",
+ "[step] 1 [mut] 0.855 [best] 96.11229392543888\n",
+ "[step] 2 [mut] 0.8122499999999999 [best] 93.76996122899693\n",
+ "[step] 3 [mut] 0.7716374999999999 [best] 93.76996122899693\n",
+ "[step] 4 [mut] 0.7330556249999999 [best] 93.36477102051143\n",
+ "[step] 5 [mut] 0.6964028437499998 [best] 93.36477102051143\n",
+ "[step] 6 [mut] 0.6615827015624998 [best] 93.36477102051143\n",
+ "[step] 7 [mut] 0.6285035664843748 [best] 90.01149831972343\n",
+ "[step] 8 [mut] 0.597078388160156 [best] 90.01149831972343\n",
+ "[step] 9 [mut] 0.5672244687521482 [best] 89.10668237027161\n",
+ "[step] 10 [mut] 0.5388632453145408 [best] 89.10668237027161\n",
+ "[step] 11 [mut] 0.5119200830488138 [best] 89.10668237027161\n",
+ "[step] 12 [mut] 0.486324078896373 [best] 75.20103046245312\n",
+ "[step] 13 [mut] 0.4620078749515544 [best] 75.20103046245312\n",
+ "[step] 14 [mut] 0.43890748120397666 [best] 75.20103046245312\n",
+ "[step] 15 [mut] 0.4169621071437778 [best] 75.10440611823527\n",
+ "[step] 16 [mut] 0.3961140017865889 [best] 75.10440611823527\n",
+ "[step] 17 [mut] 0.37630830169725943 [best] 74.94828839659989\n",
+ "[step] 18 [mut] 0.3574928866123964 [best] 74.94828839659989\n",
+ "[step] 19 [mut] 0.33961824228177656 [best] 74.94828839659989\n",
+ "[step] 20 [mut] 0.3226373301676877 [best] 74.94828839659989\n",
+ "[step] 21 [mut] 0.3065054636593033 [best] 74.94828839659989\n",
+ "[step] 22 [mut] 0.29118019047633814 [best] 74.23355449180846\n",
+ "[step] 23 [mut] 0.2766211809525212 [best] 74.21961177789215\n",
+ "[step] 24 [mut] 0.26279012190489515 [best] 74.21961177789215\n",
+ "[step] 25 [mut] 0.24965061580965037 [best] 74.21961177789215\n",
+ "[step] 26 [mut] 0.23716808501916783 [best] 73.987618045175\n",
+ "[step] 27 [mut] 0.22530968076820942 [best] 73.987618045175\n",
+ "[step] 28 [mut] 0.21404419672979894 [best] 73.987618045175\n",
+ "[step] 29 [mut] 0.20334198689330898 [best] 73.987618045175\n",
+ "[step] 30 [mut] 0.19317488754864354 [best] 73.987618045175\n",
+ "[step] 31 [mut] 0.18351614317121134 [best] 73.987618045175\n",
+ "[step] 32 [mut] 0.17434033601265078 [best] 73.987618045175\n",
+ "[step] 33 [mut] 0.16562331921201823 [best] 73.987618045175\n",
+ "[step] 34 [mut] 0.15734215325141732 [best] 73.987618045175\n",
+ "[step] 35 [mut] 0.14947504558884644 [best] 73.987618045175\n",
+ "[step] 36 [mut] 0.14200129330940411 [best] 73.987618045175\n",
+ "[step] 37 [mut] 0.1349012286439339 [best] 73.987618045175\n",
+ "[step] 38 [mut] 0.1281561672117372 [best] 73.987618045175\n",
+ "[step] 39 [mut] 0.12174835885115033 [best] 73.987618045175\n",
+ "[step] 40 [mut] 0.11566094090859282 [best] 73.987618045175\n",
+ "[step] 41 [mut] 0.10987789386316317 [best] 73.987618045175\n",
+ "[step] 42 [mut] 0.104383999170005 [best] 73.987618045175\n",
+ "[step] 43 [mut] 0.09916479921150474 [best] 73.987618045175\n",
+ "[step] 44 [mut] 0.0942065592509295 [best] 73.987618045175\n",
+ "[step] 45 [mut] 0.08949623128838302 [best] 73.987618045175\n",
+ "[step] 46 [mut] 0.08502141972396386 [best] 73.987618045175\n",
+ "[step] 47 [mut] 0.08077034873776566 [best] 73.987618045175\n",
+ "[step] 48 [mut] 0.07673183130087738 [best] 73.987618045175\n",
+ "[step] 49 [mut] 0.0728952397358335 [best] 73.987618045175\n",
+ "[step] 50 [mut] 0.06925047774904183 [best] 73.987618045175\n",
+ "[step] 51 [mut] 0.06578795386158974 [best] 73.987618045175\n",
+ "[step] 52 [mut] 0.06249855616851025 [best] 73.987618045175\n",
+ "[step] 53 [mut] 0.05937362836008474 [best] 73.987618045175\n",
+ "[step] 54 [mut] 0.0564049469420805 [best] 73.987618045175\n",
+ "[step] 55 [mut] 0.05358469959497647 [best] 73.987618045175\n",
+ "[step] 56 [mut] 0.050905464615227644 [best] 73.987618045175\n",
+ "[step] 57 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 58 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 59 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 60 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 61 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 62 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 63 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 64 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 65 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 66 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 67 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 68 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 69 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 70 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 71 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 72 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 73 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 74 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 75 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 76 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 77 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 78 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 79 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 80 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 81 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 82 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 83 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 84 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 85 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 86 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 87 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 88 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 89 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 90 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 91 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 92 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 93 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 94 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 95 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 96 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 97 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 98 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 99 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 100 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 101 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 102 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 103 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 104 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 105 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 106 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 107 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 108 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 109 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 110 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 111 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 112 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 113 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 114 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 115 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 116 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 117 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 118 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 119 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 120 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 121 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 122 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 123 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 124 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 125 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 126 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 127 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 128 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 129 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 130 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 131 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 132 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 133 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 134 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 135 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 136 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 137 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 138 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 139 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 140 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 141 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 142 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 143 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 144 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 145 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 146 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 147 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 148 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 149 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 150 [mut] 0.05 [best] 73.987618045175\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[step] 151 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 152 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 153 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 154 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 155 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 156 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 157 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 158 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 159 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 160 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 161 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 162 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 163 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 164 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 165 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 166 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 167 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 168 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 169 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 170 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 171 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 172 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 173 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 174 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 175 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 176 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 177 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 178 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 179 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 180 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 181 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 182 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 183 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 184 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 185 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 186 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 187 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 188 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 189 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 190 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 191 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 192 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 193 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 194 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 195 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 196 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 197 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 198 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 199 [mut] 0.05 [best] 73.987618045175\n",
+ "[step] 200 [mut] 0.05 [best] 73.987618045175\n",
+ "[*] [Node] 16, [Best] 73.987618045175\n",
+ "[*] Running for: 32.92 seconds\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = MyGAModel()\n",
+ "\n",
+ "print(\"Genetic Algorithm\")\n",
+ "best_solution, fitness_list, time = TSP_Bench(tsp_problem, model, max_it=200)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 383,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[]"
+ ]
+ },
+ "execution_count": 383,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.plot(fitness_list, 'o-')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 384,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plotTSP([best_solution], load_data(tsp_problem), num_iters=1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 386,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Best Fitness:\t 73.987618045175\n",
+ "Best Fitness:\t 74.10873595815309\n"
+ ]
+ }
+ ],
+ "source": [
+ "print (\"Best Fitness:\\t\", fitness(best_solution, ulysses16))\n",
+ "print (\"Best Fitness:\\t\", fitness(best_ulysses16, ulysses16))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Your Smart Model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 72,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import math\n",
+ "import random\n",
+ "from model.base_model import Model\n",
+ "\n",
+ "class MyModel(Model):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ "\n",
+ " def init(self, nodes):\n",
+ " \"\"\"\n",
+ " Put your initialization here.\n",
+ " \"\"\"\n",
+ " super().init(nodes)\n",
+ " self.log(\"Nothing to initialize in your model now\")\n",
+ "\n",
+ " def fit(self, max_it):\n",
+ " \"\"\"\n",
+ " Put your iteration process here.\n",
+ " \"\"\"\n",
+ " self.log(\"Naive Random Solution\")\n",
+ " self.best_solution = np.random.permutation(self.N).tolist()\n",
+ " self.fitness_list.append(self.fitness(self.best_solution))\n",
+ "\n",
+ " return self.best_solution, self.fitness_list"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Test your Model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 73,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tsp_problem = './template/data/simple/ulysses16.tsp'"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 74,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[MyModel] Nothing to initialize in your model now\n",
+ "[MyModel] Naive Random Solution\n",
+ "[*] [Node] 16, [Best] 147.19356281214667\n",
+ "[*] Running for: 0.01 seconds\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = MyModel()\n",
+ "best_solution, fitness_list, time = TSP_Bench(tsp_file, model)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Test All Dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 90,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "./template/data/medium/pcb442.tsp\n",
+ "./template/data/medium/a280.tsp\n",
+ "./template/data/hard/dsj1000.tsp\n",
+ "./template/data/simple/att48.tsp\n",
+ "./template/data/simple/ulysses16.tsp\n",
+ "./template/data/simple/st70.tsp\n"
+ ]
+ }
+ ],
+ "source": [
+ "for root, _, files in os.walk('./template/data'):\n",
+ " if(files):\n",
+ " for f in files:\n",
+ " print(str(root) + \"/\" + f)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 91,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def plot_results(best_solutions, times, title):\n",
+ " fig = plt.figure()\n",
+ " nodes = [len(s) for s in best_solutions]\n",
+ " data = np.array([[node, time] for node, time in sorted(zip(nodes, times))])\n",
+ " plt.plot(data[:, 0], data[:, 1], 'o-')\n",
+ " fig.suptitle(title, fontsize=20)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 94,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tsp_path = './template/data/medium'"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 95,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Random Search\n",
+ "[*] ./template/data/medium/pcb442.tsp\n",
+ "[*] [Node] 442, [Best] 722875.708265324\n",
+ "[*] Running for: 0.26 seconds\n",
+ "\n",
+ "[*] ./template/data/medium/a280.tsp\n",
+ "[*] [Node] 280, [Best] 31126.512432333657\n",
+ "[*] Running for: 0.16 seconds\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = MyRandomModel()\n",
+ "\n",
+ "print(\"Random Search\")\n",
+ "best_solutions, fitness_lists, times = TSP_Bench_ALL(tsp_path, model)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 79,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plot_results(best_solutions, times, \"Random Model\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 82,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Genetic Algorithm\n",
+ "[*] ./template/data/medium/pcb442.tsp\n",
+ "'module' object is not callable\n",
+ "[*] Unkown -4\n",
+ "[*] No Answer -1\n",
+ "[*] Running for: 0.12 seconds\n",
+ "\n",
+ "[*] ./template/data/medium/a280.tsp\n",
+ "'module' object is not callable\n",
+ "[*] Unkown -4\n",
+ "[*] No Answer -1\n",
+ "[*] Running for: 0.05 seconds\n",
+ "\n",
+ "[*] ./template/data/hard/dsj1000.tsp\n",
+ "'module' object is not callable\n",
+ "[*] Unkown -4\n",
+ "[*] No Answer -1\n",
+ "[*] Running for: 0.38 seconds\n",
+ "\n",
+ "[*] ./template/data/simple/att48.tsp\n",
+ "'module' object is not callable\n",
+ "[*] Unkown -4\n",
+ "[*] No Answer -1\n",
+ "[*] Running for: 0.01 seconds\n",
+ "\n",
+ "[*] ./template/data/simple/ulysses16.tsp\n",
+ "'module' object is not callable\n",
+ "[*] Unkown -4\n",
+ "[*] No Answer -1\n",
+ "[*] Running for: 0.00 seconds\n",
+ "\n",
+ "[*] ./template/data/simple/st70.tsp\n",
+ "'module' object is not callable\n",
+ "[*] Unkown -4\n",
+ "[*] No Answer -1\n",
+ "[*] Running for: 0.01 seconds\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = MyGAModel()\n",
+ "\n",
+ "print(\"Genetic Algorithm\")\n",
+ "best_solutions, fitness_lists, times = TSP_Bench_ALL(tsp_path, model, max_it=100, timeout=600)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 81,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plot_results(best_solutions, times, \"Genetic Algorithm\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "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.5"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/images/ab-pruning.png b/images/ab-pruning.png
new file mode 100644
index 0000000..6d60996
Binary files /dev/null and b/images/ab-pruning.png differ
diff --git a/images/minimax.png b/images/minimax.png
new file mode 100644
index 0000000..cae1c80
Binary files /dev/null and b/images/minimax.png differ
diff --git a/images/pwd.png b/images/pwd.png
new file mode 100644
index 0000000..bdc8256
Binary files /dev/null and b/images/pwd.png differ
diff --git a/images/solutions.png b/images/solutions.png
new file mode 100644
index 0000000..4e2e934
Binary files /dev/null and b/images/solutions.png differ
diff --git a/images/terminal.png b/images/terminal.png
new file mode 100644
index 0000000..8e15da3
Binary files /dev/null and b/images/terminal.png differ
diff --git a/images/tsp.jpg b/images/tsp.jpg
new file mode 100644
index 0000000..cf8fedc
Binary files /dev/null and b/images/tsp.jpg differ
diff --git a/.dockerignore b/template/.dockerignore
similarity index 100%
rename from .dockerignore
rename to template/.dockerignore
diff --git a/.gitignore b/template/.gitignore
similarity index 100%
rename from .gitignore
rename to template/.gitignore
diff --git a/Dockerfile b/template/Dockerfile
similarity index 100%
rename from Dockerfile
rename to template/Dockerfile
diff --git a/README.md b/template/README.md
similarity index 83%
rename from README.md
rename to template/README.md
index 02cadaf..487f313 100644
--- a/README.md
+++ b/template/README.md
@@ -1,3 +1,6 @@
+## Build Image
+
+docker build -t com2014-tsp .
## Windows
diff --git a/data/hard/dsj1000.tsp b/template/data/hard/dsj1000.tsp
similarity index 100%
rename from data/hard/dsj1000.tsp
rename to template/data/hard/dsj1000.tsp
diff --git a/data/medium/a280.tsp b/template/data/medium/a280.tsp
similarity index 100%
rename from data/medium/a280.tsp
rename to template/data/medium/a280.tsp
diff --git a/data/medium/pcb442.tsp b/template/data/medium/pcb442.tsp
similarity index 100%
rename from data/medium/pcb442.tsp
rename to template/data/medium/pcb442.tsp
diff --git a/data/simple/att48.tsp b/template/data/simple/att48.tsp
similarity index 100%
rename from data/simple/att48.tsp
rename to template/data/simple/att48.tsp
diff --git a/data/simple/st70.tsp b/template/data/simple/st70.tsp
similarity index 100%
rename from data/simple/st70.tsp
rename to template/data/simple/st70.tsp
diff --git a/data/simple/ulysses16.tsp b/template/data/simple/ulysses16.tsp
similarity index 100%
rename from data/simple/ulysses16.tsp
rename to template/data/simple/ulysses16.tsp
diff --git a/main.py b/template/main.py
similarity index 96%
rename from main.py
rename to template/main.py
index dc0054b..048f30b 100644
--- a/main.py
+++ b/template/main.py
@@ -35,13 +35,13 @@ def TSP(tsp_file, model):
coords = load_data(tsp_file)
# Set timeout
- signal.signal(signal.SIGALRM, timeout_handler)
- signal.alarm(60)
+ # signal.signal(signal.SIGALRM, timeout_handler)
+ # signal.alarm(60)
# Try your algorithm
try:
model.init(coords)
- best_solution, fitness_list = model.fit(max_it=100000)
+ best_solution, fitness_list = model.fit(max_it=10000)
except Exception as exc:
if(str(exc) == "Timeout"):
log("Timeout -3")
diff --git a/model/anneal_model.py b/template/model/anneal_model.py
similarity index 98%
rename from model/anneal_model.py
rename to template/model/anneal_model.py
index 621d16b..bcb1a9d 100644
--- a/model/anneal_model.py
+++ b/template/model/anneal_model.py
@@ -72,7 +72,7 @@ class SimAnneal(Model):
self.log("Starting annealing.")
while self.T >= self.stopping_temperature and self.iteration < max_it:
candidate = list(self.cur_solution)
- l = random.randint(2, self.N - 1)
+ l = random.randint(1, self.N - 1)
i = random.randint(0, self.N - l)
candidate[i : (i + l)] = reversed(candidate[i : (i + l)])
self.accept(candidate)
diff --git a/model/base_model.py b/template/model/base_model.py
similarity index 100%
rename from model/base_model.py
rename to template/model/base_model.py
diff --git a/model/my_model.py b/template/model/my_model.py
similarity index 100%
rename from model/my_model.py
rename to template/model/my_model.py
diff --git a/template/output/.gitignore b/template/output/.gitignore
new file mode 100644
index 0000000..1c471ba
--- /dev/null
+++ b/template/output/.gitignore
@@ -0,0 +1,8 @@
+# .gitignore sample
+###################
+
+# Ignore all files in this dir...
+*
+
+# ... except for this one.
+!.gitignore
\ No newline at end of file
diff --git a/requirements.txt b/template/requirements.txt
similarity index 100%
rename from requirements.txt
rename to template/requirements.txt
diff --git a/template/utils/load_data.py b/template/utils/load_data.py
new file mode 100644
index 0000000..592fb6a
--- /dev/null
+++ b/template/utils/load_data.py
@@ -0,0 +1,21 @@
+def log(msg):
+ print('[*] {msg}'.format(msg=msg))
+
+def load_data(file):
+ coords = []
+ with open(file, "r") as infile:
+ line = infile.readline()
+ # Skip instance header
+ while "NODE_COORD_SECTION" not in line:
+ line = infile.readline()
+
+ for line in infile.readlines():
+ line = line.replace("\n", "")
+ if line and 'EOF' not in line:
+ line = [float(x) for x in line.lstrip().split(" ", 1)[1].split(" ") if x]
+ coords.append(line)
+ return coords
+
+def timeout_handler(signum, frame):
+ print("Timeout")
+ raise Exception("Timeout")
diff --git a/template/utils/tsp.py b/template/utils/tsp.py
new file mode 100644
index 0000000..d21722b
--- /dev/null
+++ b/template/utils/tsp.py
@@ -0,0 +1,139 @@
+import os
+import signal
+import json
+import math
+import timeit
+
+from utils.load_data import load_data
+from utils.load_data import log
+
+def timeout_handler(signum, frame):
+ raise Exception("Timeout")
+
+def dist(node_0, node_1, coords):
+ """
+ Euclidean distance between two nodes.
+ """
+ coord_0, coord_1 = coords[node_0], coords[node_1]
+ return math.sqrt((coord_0[0] - coord_1[0]) ** 2 + (coord_0[1] - coord_1[1]) ** 2)
+
+def fitness(solution, coords):
+ N = len(coords)
+ cur_fit = 0
+ for i in range(len(solution)):
+ cur_fit += dist(solution[i % N], solution[(i + 1) % N], coords)
+ return cur_fit
+
+def TSP_Bench(tsp_file, model, *args, max_it=1000, timeout=60):
+
+ start = timeit.default_timer()
+
+ # Model Running
+ best_solution, fitness_list = TSP(tsp_file, model, *args, max_it=max_it,timeout=timeout)
+ # Model End
+
+ stop = timeit.default_timer()
+ print('[*] Running for: {time:.2f} seconds'.format(time=(stop - start)))
+
+ print()
+ return best_solution, fitness_list, (stop - start)
+
+def TSP_Bench_ALL(tsp_file_path, model, *args, max_it=1000, timeout=60):
+ best_solutions = []
+ fitness_lists = []
+ times = []
+ for root, _, files in os.walk(tsp_file_path):
+ if(files):
+ for f in files:
+ # Get input file name
+ tsp_file = str(root) + '/' + str(f)
+ log(tsp_file)
+
+ # Run TSP
+ best_solution, fitness_list, time = TSP_Bench(tsp_file, model, *args, max_it=max_it,timeout=timeout)
+ best_solutions.append(best_solution)
+ fitness_lists.append(fitness_lists)
+ times.append(time)
+
+ return best_solutions, fitness_lists, times
+
+def TSP(tsp_file, model, *args, max_it=1000, timeout=60):
+
+ best_solution = []
+ fitness_list = []
+
+ nodes = load_data(tsp_file)
+
+ # Set timeout
+ signal.signal(signal.SIGALRM, timeout_handler)
+ signal.alarm(timeout)
+
+ if not os.path.exists('output'):
+ os.makedirs('output')
+
+ # Try your algorithm
+ try:
+ model.init(nodes, *args)
+ best_solution, fitness_list = model.fit(max_it)
+ except Exception as exc:
+ if(str(exc) == "Timeout"):
+ log("Timeout -3")
+ with open('output/' + os.path.splitext(os.path.basename(tsp_file))[0] + '.txt', "w") as outfile:
+ outfile.write("-3")
+ best_solution = [-1] * len(nodes)
+ else:
+ print(exc)
+ log("Unkown -4")
+ with open('output/' + os.path.splitext(os.path.basename(tsp_file))[0] + '.txt', "w") as outfile:
+ outfile.write("-4")
+
+ signal.alarm(0)
+
+ # Collect results
+ if(len(fitness_list) > 0):
+ log("[Node] " + str(len(best_solution)) + ", [Best] " + str(fitness_list[fitness_list.index(min(fitness_list))]))
+
+ if (len(best_solution) == 0):
+ log("No Answer -1")
+ with open('output/' + os.path.splitext(os.path.basename(tsp_file))[0] + '.txt', "w") as outfile:
+ outfile.write("-1")
+ elif (len(best_solution) != len(nodes)):
+ log("Invalid -2")
+ with open('output/' + os.path.splitext(os.path.basename(tsp_file))[0] + '.txt', "w") as outfile:
+ outfile.write("-2")
+ else:
+ # log("Writing the best solution to file" )
+ with open('output/' + os.path.splitext(os.path.basename(tsp_file))[0] + '.txt', "w") as outfile:
+ outfile.write(str(model.fitness(best_solution)))
+ outfile.write("\n")
+ outfile.write(", ".join(str(item) for item in best_solution))
+
+ # Write to JSON
+ data = {}
+
+ data['nodes'] = []
+ for i in range(len(nodes)):
+ data['nodes'].append({
+ 'title': str(i),
+ 'id': i,
+ 'x': int(nodes[i][0]),
+ 'y': int(nodes[i][1])
+ })
+
+ data['edges'] = []
+ for i in range(len(best_solution)):
+ if i == len(best_solution)-1:
+ data['edges'].append({
+ 'source': best_solution[i],
+ 'target': best_solution[0]
+ })
+ else:
+ data['edges'].append({
+ 'source': best_solution[i],
+ 'target': best_solution[i+1]
+ })
+
+ with open('output/' + os.path.splitext(os.path.basename(tsp_file))[0] + '.json', 'w') as outfile:
+ json.dump(data, outfile)
+
+ return best_solution, fitness_list
\ No newline at end of file
diff --git a/utils/visualize_tsp.py b/template/utils/visualize_tsp.py
similarity index 100%
rename from utils/visualize_tsp.py
rename to template/utils/visualize_tsp.py