From 4bd416f161aec5b5aca1fd2e02c84d7634d39b6a Mon Sep 17 00:00:00 2001 From: erelsaul Date: Fri, 15 Jul 2016 01:33:43 +0300 Subject: [PATCH 1/4] Mazr_Solver_Erel_Saul --- .../Python and State Machines.ipynb | 65 +- .../StateMachine_EREL_SAUL.ipynb | 93 +++ projects/3-mazes/Maze Solvers_EREL_SAUL.ipynb | 635 ++++++++++++++++++ 3 files changed, 777 insertions(+), 16 deletions(-) create mode 100644 projects/2-state-machines/StateMachine_EREL_SAUL.ipynb create mode 100644 projects/3-mazes/Maze Solvers_EREL_SAUL.ipynb diff --git a/projects/2-state-machines/Python and State Machines.ipynb b/projects/2-state-machines/Python and State Machines.ipynb index f005eb9..0b6589d 100644 --- a/projects/2-state-machines/Python and State Machines.ipynb +++ b/projects/2-state-machines/Python and State Machines.ipynb @@ -70,7 +70,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { "collapsed": false }, @@ -142,11 +142,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { "collapsed": false }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial state: s1\n", + "Accepting? False\n", + "After a: s2\n", + "After ab: s3\n", + "Next steps: {'a': 's3'}\n", + "Accepting? True\n" + ] + } + ], "source": [ "ab_a_ = StateMachine(\n", " #We can define the states and edges in one go\n", @@ -182,7 +195,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": { "collapsed": true }, @@ -201,7 +214,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": { "collapsed": false }, @@ -229,14 +242,17 @@ "assert not check(test1(), \"hel\")\n", "assert not check(test1(), \"helloy\")\n", "assert not check(test1(), \"hih\")\n", - "assert not check(test1(), \"heyhey\")" + "assert not check(test1(), \"heyhey\")\n", + "\n" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "collapsed": true + }, "source": [ - "Next, define a state machine which accepts email addresses consisting only of the letter \"x\" and the symbols \"@\" and \".\" (in other words, you don't need a ton of edges). Devise tests for it below (try to be sinister---get a partner to come up with adversarial examples too)." + "# Next, define a state machine which accepts email addresses consisting only of the letter \"x\" and the symbols \"@\" and \".\" (in other words, you don't need a ton of edges). Devise tests for it below (try to be sinister---get a partner to come up with adversarial examples too)." ] }, { @@ -292,11 +308,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": { "collapsed": false }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ab\n", + "abc\n" + ] + } + ], "source": [ "ab = \"a\" + \"b\"\n", "print(ab)\n", @@ -313,11 +338,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": { - "collapsed": true + "collapsed": false }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['a', 'b', 'c']\n" + ] + } + ], "source": [ "lst_abc = [\"a\",\"b\"] + [\"c\"]\n", "print(lst_abc)" @@ -428,9 +461,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python [Root]", "language": "python", - "name": "python3" + "name": "Python [Root]" }, "language_info": { "codemirror_mode": { @@ -442,7 +475,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.1" + "version": "3.5.2" } }, "nbformat": 4, diff --git a/projects/2-state-machines/StateMachine_EREL_SAUL.ipynb b/projects/2-state-machines/StateMachine_EREL_SAUL.ipynb new file mode 100644 index 0000000..085f8f4 --- /dev/null +++ b/projects/2-state-machines/StateMachine_EREL_SAUL.ipynb @@ -0,0 +1,93 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "#ASSIGNMENT 1.1\n", + "def check(sm, string):\n", + " for s in string:\n", + "#for loop is used to go through each letter of the string \n", + " if s not in sm.out_edges():\n", + "#if statement here is used to check if the letter corresponds to the next edge. \n", + "#if it does NOT correspond to any out edges then it returns FALSE\n", + " return False\n", + "#this basically means that it doesn't pass the conditions of the state machine\n", + " sm.advance(s)\n", + "#if the selected letter does correspond to the any of the out edges we reassign the \n", + "#machine's state to be the target state denoted by that symbol, among the current out edges.\n", + " return sm.is_terminal()\n", + "#if the string gets to this point than it means that all letter of the string has \n", + "#successfully passed the requirments and the state machine is in a terminal state \n", + "#since its current state is terminal\n", + "\n", + "\n", + "\n", + "#ASSIGNMENT 1.2\n", + "def test2():\n", + " #(x+@x+\\.x+(\\.x+)*)\n", + " return StateMachine([(\"s1\", \"x\", \"s2\"), (\"s2\", \"x\", \"s2\"), (\"s2\", \"@\", \"s3\"),\n", + " (\"s3\", \"x\", \"s4\"), (\"s4\", \"x\", \"s4\"), (\"s4\", \".\", \"s5\"),\n", + " (\"s5\", \"x\", \"s6\"), (\"s6\", \"x\", \"s6\"), (\"s6\", \".\", \"s7\"),\n", + " (\"s7\", \"x\", \"s6\")],\n", + " \"s1\",\n", + " [\"s6\"])\n", + "#this function pretty much works the same with the previous one, however this time instead having\n", + "#the out edges, we have created ourselves. We will also use the previous check function to basically\n", + "#check if the input string matches with the conditions we set. First, we check if the first letter is x.\n", + "#This is our number one condition. If it is, we continue to the second out edge. There are 2 options for the\n", + "#second edge, meaning the second letter can either be, once again, x or it can be the @ sign. Notice how \n", + "#the second edge with the x option has both s2's, (\"s2\", \"x\", \"s2\"). That's because there could be\n", + "#as many x's as the mail provider allows. So, if it's x again, then it will stay at the same edge until @ sign\n", + "#or any other sign/letter is used. If @ sign is used then it will go through edge 3 which expects x. After that, \n", + "#it can either take as many x's it can take or it can take a dot, which is edge 5. The same process goes with edges\n", + "#6 and 7. When the loop ends if the conditions are met the state machine terminates, if not it returns false. \n", + "\n", + "#ASSIGNMENT 2\n", + "def sample2(sm, length, sofar):\n", + " # Each path of length 0 is either accepting or non-accepting;\n", + " # in the former case we return [sofar] (the path) and in the latter [] (no path)\n", + " if length == 0:\n", + " if sm.is_terminal():\n", + " return [sofar]\n", + " else:\n", + " return []\n", + " state = sm.state\n", + " results = []\n", + " for sym in sm.out_edges():\n", + " # for each edge: advance, sample, backtrack.\n", + " sm.advance(sym)\n", + " results = results + sample2(sm, length-1, sofar + sym)\n", + " sm.state = state\n", + " return results\n", + "\n" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [Root]", + "language": "python", + "name": "Python [Root]" + }, + "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.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/projects/3-mazes/Maze Solvers_EREL_SAUL.ipynb b/projects/3-mazes/Maze Solvers_EREL_SAUL.ipynb new file mode 100644 index 0000000..5741379 --- /dev/null +++ b/projects/3-mazes/Maze Solvers_EREL_SAUL.ipynb @@ -0,0 +1,635 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we load up some useful libraries for visualization and data structures." + ] + }, + { + "cell_type": "code", + "execution_count": 232, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n", + "import matplotlib\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.patches as patches\n", + "import matplotlib.axes as axes\n", + "import copy\n", + "import random\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from collections import deque " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we need a Maze class for pathfinding. It will help to have read the RedBlobGames [A\\* tutorial](http://www.redblobgames.com/pathfinding/a-star/introduction.html) before continuing.\n", + "\n", + "These Mazes are defined in ASCII diagrams and can have walls (\"#\"), empty spaces (\".\"), switches (numbers), and doors (letters; closed are uppercase). The \"0\" switch toggles the open status of all the \"a\" doors, \"1\" goes to the \"b\" doors, etc. Mazes can also contain pits: \"?\" pits have a 30% chance of killing the player and \"!\" pits have a 60% chance. Every maze has one player start location \"@\" and one goal square \"X\". Walls and closed doors block movement." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "invalid syntax (, line 16)", + "output_type": "error", + "traceback": [ + "\u001b[1;36m File \u001b[1;32m\"\"\u001b[1;36m, line \u001b[1;32m16\u001b[0m\n\u001b[1;33m self.player_pos = None-\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n" + ] + } + ], + "source": [ + "class Maze:\n", + " SwitchMap = {\"0\":\"a\", \"1\":\"b\", \"2\":\"c\", \"3\":\"d\", \"4\":\"e\", \"5\":\"f\", \"6\":\"g\", \"7\":\"h\", \"8\":\"i\", \"9\":\"j\"}\n", + " Colors = {\"a\":\"coral\",\"b\":\"tan\",\"c\":\"palegreen\",\"d\":\"blue\",\"e\":\"cyan\",\"f\":\"magenta\",\"g\":\"yellow\",\"h\":\"olive\",\"i\":\"purple\",\"j\":\"darkgreen\",\n", + " \"0\":\"coral\",\"1\":\"tan\",\"2\":\"palegreen\",\"3\":\"blue\",\"4\":\"cyan\",\"5\":\"magenta\",\"6\":\"yellow\",\"7\":\"olive\",\"8\":\"purple\",\"9\":\"darkgreen\",\n", + " \"?\":\"orange\",\n", + " \"!\":\"red\",\n", + " \"x\":\"green\",\"@\":\"gray\",\n", + " \"#\":\"sienna\",\".\":\"white\"}\n", + " \n", + " def __init__(self,rows):\n", + " self.grid = [list(r) for r in rows]\n", + " self.grid.reverse()\n", + " height = len(self.grid)\n", + " width = len(self.grid[0])\n", + " self.exit_pos = None\n", + " self.player_pos = None-\n", + " (px,py) = self.player_pos\n", + " switchnum = self.grid[py][px]\n", + " assert switchnum.isnumeric()\n", + " for y in range(0,height):\n", + " for x in range(0,width):\n", + " self.grid[y][x] = self.toggle_cell(switchnum,self.grid[y][x])\n", + " \n", + " def is_free(self,x,y):\n", + " if y < 0 or y >= len(self.grid):\n", + " return False\n", + " if x < 0 or x >= len(self.grid[0]):\n", + " return False\n", + " cell = self.grid[y][x]\n", + " return (\n", + " cell == \".\" or\n", + " cell == \"?\" or cell == \"!\" or \n", + " (cell.isalpha() and cell.islower()) or cell.isnumeric()\n", + " )\n", + " \n", + " def move_player(self,dx,dy):\n", + " assert self.player_alive\n", + " assert abs(dx)+abs(dy) == 1\n", + " (x,y) = self.player_pos\n", + " (newx,newy) = (x+dx,y+dy)\n", + " assert self.is_free(newx,newy)\n", + " self.player_pos = (x+dx,y+dy)\n", + " cell = self.grid[y+dy][x+dx]\n", + " if cell == \"?\" and random.random() < 0.3:\n", + " self.player_alive = False\n", + " if cell == \"!\" and random.random() < 0.6:\n", + " self.player_alive = False\n", + " \n", + " def available_moves(self):\n", + " if not self.player_alive:\n", + " return []\n", + " (x,y) = self.player_pos\n", + " can_switch = self.grid[y][x].isnumeric()\n", + " return [(dx,dy) for (dx,dy) in [(-1,0),(1,0),(0,-1),(0,1)] if self.is_free(x+dx,y+dy)] + (\n", + " [\"switch\"] if can_switch else []\n", + " )\n", + " \n", + " def is_at_exit(self):\n", + " return self.player_alive and self.player_pos == self.exit_pos\n", + " \n", + " def draw(self):\n", + " fig1 = plt.figure()\n", + " ax1 = fig1.add_subplot(1,1,1, aspect='equal')\n", + " ax1.set_axis_bgcolor('sienna')\n", + " height = len(self.grid)\n", + " width = len(self.grid[0])\n", + " ax1.set_xlim([0,width])\n", + " ax1.set_ylim([0,height])\n", + " for y in range(0,height):\n", + " for x in range(0,width):\n", + " cell = self.grid[y][x]\n", + " if cell == \"#\": continue\n", + " is_door = cell.isalpha() and cell.lower() != \"x\"\n", + " is_pit = cell == \"?\" or cell == \"!\"\n", + " is_open = is_door and cell.islower()\n", + " is_switch = cell.isnumeric()\n", + " ax1.add_patch(\n", + " patches.Rectangle((x, y),\n", + " 1,1,\n", + " fill=True,\n", + " facecolor=Maze.Colors[cell.lower()],\n", + " edgecolor=\"black\",\n", + " hatch=\"/\" if is_switch else (\"-\" if (is_door and not is_open) else None),\n", + " label=cell)\n", + " )\n", + " ax1.add_patch(\n", + " patches.Rectangle(self.player_pos,\n", + " 1,1,\n", + " fill=True,\n", + " hatch=\"x\" if not self.player_alive else None,\n", + " facecolor=Maze.Colors[\"@\"] if self.player_alive else \"black\",\n", + " edgecolor=Maze.Colors[\"@\"] if self.player_alive else \"white\")\n", + " )\n", + " plt.show(fig1)\n", + "\n", + "sample=Maze([\n", + " \"##X#\",\n", + " \"#.A#\",\n", + " \"#0?#\",\n", + " \"a@##\"\n", + " ])\n", + "print (sample.player_pos)\n", + "sample.move_player(0,1)\n", + "print(sample.available_moves())\n", + "sample.move_player(1,0)\n", + "sample.draw()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Assignment 1\n", + "\n", + "Write a function to solve pathfinding and switch-and-door puzzles with one of the heuristic search algorithms described during the lecture. Try it on the provided sample puzzles; if a puzzle gives your algorithm trouble, try to explain why that happens. Make sure the path you're getting is the actual shortest path!\n", + "\n", + "Try to get this assignment done by Friday; the other two may take a little longer but the sooner you attempt them the earlier you can get feedback!\n", + "\n", + "You may also try visualizing paths through the maze, implementing several different heuristic searches, comparing against aheuristic search, etc.\n", + "\n", + "Generating mazes automatically would also be a great exercise!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def heur(a, b):\n", + " # Manhattan distance on a square grid\n", + " return abs(a.x - b.x) + abs(a.y - b.y)" + ] + }, + { + "cell_type": "code", + "execution_count": 234, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def heuri(a, b):\n", + " (x1, y1) = a\n", + " (x2, y2) = b\n", + " return abs(x1 - x2) + abs(y1 - y2) \n", + "\n", + "\n", + "def heuristic(maze):\n", + " # Return a path which solves the maze: a sequence of elements like (dx,dy) or \"switch\".\n", + " # You can use maze.exit_pos and query maze.grid[row][column] to investigate the maze.\n", + " \n", + " \n", + " frontier = PriorityQueue()\n", + " frontier.put(maze.player_pos, 0)\n", + " came_from = {}\n", + " cost_so_far = {}\n", + " came_from[start] = None\n", + " cost_so_far[start] = 0\n", + " \n", + " while not frontier.empty():\n", + " current = frontier.get()\n", + " \n", + " if current == maze.exit_pos:\n", + " break\n", + " \n", + " for next in graph.neighbors(current):\n", + " new_cost = cost_so_far[current] + graph.cost(current, next)\n", + " if next not in cost_so_far or new_cost < cost_so_far[next]:\n", + " cost_so_far[next] = new_cost\n", + " priority = new_cost + heuristic(goal, next)\n", + " frontier.put(next, priority)\n", + " came_from[next] = current\n", + " \n", + " return came_from, cost_so_far\n", + "\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " return []" + ] + }, + { + "cell_type": "code", + "execution_count": 235, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOIAAAEACAYAAACu66rqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n4CCaJeAgmiXgIJol4CCaJfB/quNiKOmyu7oAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAU8AAAD7CAYAAADq4RYlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAU8AAAD7CAYAAADq4RYlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nngCQQHkCQALlCQAJlCcAJFCeAJDwf/33eWSmMrQpAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def maze1():\n", + " return Maze([\n", + " \"########\",\n", + " \"#X.#...#\",\n", + " \"#.##.#.#\",\n", + " \"#.#..#.#\",\n", + " \"#....#.#\",\n", + " \"#.##...#\",\n", + " \"#..#..##\",\n", + " \"##.#..@#\",\n", + " \"########\"\n", + " ])\n", + "\n", + "maze1().draw()\n", + "\n", + "def maze2():\n", + " return Maze([\n", + " \"###############\",\n", + " \"#X#@.#.#...#..#\",\n", + " \"#.##.....#....#\",\n", + " \"#.#.#.#..#..#.#\",\n", + " \"#...#.#....#..#\",\n", + " \"#.#.#.........#\",\n", + " \"#.#.##.#..#...#\",\n", + " \"#.....#..#..#.#\",\n", + " \"#####...#.....#\",\n", + " \"########...####\",\n", + " \"###############\"\n", + " ])\n", + "\n", + "maze2().draw()\n", + "\n", + "def mazeUnsolvable1():\n", + " return Maze([\n", + " \"###############\",\n", + " \"#X#@.#.#...#..#\",\n", + " \"#.##.....#....#\",\n", + " \"#.#.#.#..#..#.#\",\n", + " \"#.#.#.#....#..#\",\n", + " \"#..##...#.....#\",\n", + " \"#.#.##....#...#\",\n", + " \"#.#...#..#..#.#\",\n", + " \"#####...#.....#\",\n", + " \"########...####\",\n", + " \"###############\"\n", + " ])\n", + "\n", + "mazeUnsolvable1().draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false, + "scrolled": true + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'heuristic' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mheuristic\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmaze1\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mheuristic\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmaze2\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mheuristic\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmazeUnsolvable1\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mNameError\u001b[0m: name 'heuristic' is not defined" + ] + } + ], + "source": [ + "print(heuristic(maze1()))\n", + "print(heuristic(maze2()))\n", + "print(heuristic(mazeUnsolvable1()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You also have to be able to handle switch and door puzzles:" + ] + }, + { + "cell_type": "code", + "execution_count": 237, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAU8AAAD7CAYAAADq4RYlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n/D+POh+f+M9ZsgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOIAAAEACAYAAACu66rqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAEhlJREFUeJzt3X+Q3HV9x/Hn63J3uUtOGFsDtSIBihhwyAAFpEYEisgP\no1ZmGEGLE4ehE2wHxjZW5I9C2qmDeo7FaWsGVMA0Yic04Yf0BygDjnTECIEc5IciUgJCiCMmk5Ij\nl+TdP/YbCpvL7nf3vp+973f39ZjJ3O7x3c/nvXu89vtjv/v+KiIws+nVN90FmJmDaFYKDqJZCTiI\nZiXgIJqVgINoVgK5gijpKklj2b8rUxdl1muaBlHSu4DLgJOBE4CFko5KXZhZL8mzRjwWeDgiXo2I\nPcAPgQvTlmXWW/IE8QngdElvljQLuAB4e9qyzHpLf7MFImKjpC8C9wE7gLXAntSFmfUStXquqaS/\nBzZHxLK63/ukVbNJRISaLdN0jQggaU5EbJV0OPBR4LTJlrvlwuNbq7AFq9dv4aPHHZpsfM9Rrjm6\n4TkALFo1lmu5XEEE/k3S7wATwKcjYnu7hZnZ/nIFMSLel7oQs15WmTNr5s2Z7Tl6aI5ueA6taPlg\nzQEHkiLlPqJZFS1aNZbrYE1l1ohm3cxBNCsBB9GsBBxEsxJwEM1KwEE0KwEH0awEHESzEnAQzUrA\nQTQrAQfRrAQcRLMScBDNSsBBNCuBvA2GPy/pSUnrJK2QNJi6MLNekqfB8FzgcuDEiJhP7Vv9F6cu\nzKyX5GmVsR3YBcyWtBeYBfwqaVVmPabpGjEiXga+AjwLPA/8NiK+n7ows17SdI2YXefiM8BcYBtw\nu6SPR8R36pddvX7La7fnzZnNsXNGCit0/R+cx6zZaXuM7Nixg9HR0aRzHDJ7kC+d+86kc/z1D37J\nS9t2JJ1jeGAGOyfS9ZkeGuxnfNfuZOMDzHnTEF8+5x2Fjrlh6w42bv3flh+XZ9P0ZOChiPgNgKRV\nwHuA/YKYskdk6hACjIyMENf+ScuPe+CZrVy0cg0rLzqFM4+Y03BZLb2j3fJye2nbDorqRXQgknK/\nVq28Pq+Nv/QO1n0v35vimnVPseT65YxefSmnzD8612MA5i9cknvZvI6dM/KGFdCdG1/K9bg8R003\nAadJGpIk4GxgQztFdqN2/ifrJalfn3ZDWDZ59hEfB74NPAI8Dgi4MXFdleAQNuYQ5pe3wfCXgS8n\nrqVSHMLGHMLW+MyaNjiEjTmErXMQW+QQNuYQtsdBbIFD2JhD2D4HMSeHsDGHcGocxBwcwsYcwqlz\nEJtwCBtzCIvhIDbgEDbmEBbHQTwAh7C51K9PyhCuWfdU4WNOhYM4CYcwn1SvzwPPbAVIGsIl1y8v\nfNypcBDrOIT5pQrhRSvXACQN4ejVlxY+9lQ4iHVShnDfO71N7vVvgimUeZ/TQayTMoT73ultf71+\n4MdBrJMyhKne6auu10MIDmJy3udszCGscRATcggbcwj/n4OYiEPYmEP4Rnn6mh4jaa2kR7Of2yRd\n2YniqsohbMwh3F/Tb+hHxM+AEwEk9QHPAasT11VZDmFjDuHkWt00fT/wi4jYnKKYqnMIG3MID6zV\nIH4MuC1FIVXnEDbmEDamvP0vJQ1Qa7V/XETsd4qIpPjIvENeu190g+EnjjqXkZHixptMJxoMDw/M\n4OsfOi7pHFf8x8/ZuXM86RxD/TMY352uwfDMgX5enUjbYHhosJ9lC48tdMz6BsN3bnyJiFCzx+Xq\n4pY5H3hkshDuk7LB8OjoaFvNf1uh0fxNbfdp9Z04RVPbejt3jrNsYlnSORYPLOaWC49PNv6iVWPp\n/94Jmj2nbDC8zyV4s/QNqr45ZOWR9/qIs6gdqFmVtpzqcAitSHkbDL8CTPsRiOseKEen/yqE8O6/\nvXu6S7AW+MyaFlUhhFY9rRysmXbXnVnsEa56Sx/c1PC/VymEH/qbDyUd/56/uyfp+L3Ga8ScqhRC\nqx4HMQeH0FJzEJtwCK0THMQGHELrFAfxABxC6yQHcRIOoXWag1jHIbTp4CDW6aU271YeDmKdXmrz\nbuVRrTNrOnCuaeo275ddk/brSfv4XNNq8RoxMe9zWh7VWiNO87mmrZrOEPpc02rxGjERrwmtFQ5i\nAg6htSrvN/QPlrRS0gZJT0p6d+rCqsohtHbk3Ue8Afj3iLhIUj8wK2FNleUQWruaBlHSQcDpEbEI\nICJ2A9sT11U5DqFNRZ5N0yOBX0u6Obv+xY2ShlMXViUOoU1V0wbDkv4Q+DHwRxHxU0n/AGyLiGvr\nlkvaYPiKu55k5+69hY03mc40tR1gfNdE0jkGhgaYGE87x+DwADeePy/Z+FfcvZ6dE+kaGEOaZs8p\nGww/B2yOiJ9m928HPjfZgikbDO/cvbflhrOttnnX0juSNs2FrHFuzu7q7ZLUkTlS2jmxp5LPIVmD\n4YjYAmyWdEz2q7OB9W3U2FG+FoVVSd6jplcCK7LrXzwNfCpdSVPnEFrV5G0w/DhwSuJaCuEQWhV1\n1Zk1DqFVVdcE0SG0KuuKIDqEVnWVD6JDaN2g0kF0CK1bVDaIDqF1k0oG0SG0blO5IDqE1o0qFUSH\n0LpVpYKYMoQPPLO18DHN8qpUEFOG8KKVawof1yyvSgUxZQhXXlSJU2mtS1UqiEXzPqeVRc8G0SG0\nMunJIDqEVja5vo8o6RlgG7AXmIiIU1MWlZJDaGWU9xv6e4EzI+LllMWk5hBaWeXdNFULy5aSQ2hl\nljdcAdwnaY2ky1MWlIJDaGWXd9N0QUS8IGkOtUBuiIgfpSysKA6hVUHe5lEvZD+3SloNnArsF8TV\n67e8drvoBsPD/X1o6R1tP/6sWx9qusxQfx+LVo21PUceQ0NDyXuCdmKO4eGh5ONX8TnUNxjOK8+1\nL2YBfRGxQ9Js4APA0smWLVuD4VZp6R2s+95o0jnmL1zCsom0l+9ePLC46RybHtzETRffxOXfvZx3\nnvHOtuZIaefO8Z5qMJxnjXgosFpSZMuviIh72ymyCv55xX9NdwnJTTWEVrymQYyIXwIndKAW6wCH\nsJzyHqzpGZ/+xLlJx192231Jx2/EISyvSn82aPk5hOXmIPYAh7D8HMQu5xBWg4PYxRzC6nAQu5RD\nWC0OYpdKGcJND24qfMxe5yB2qZQhvOnimwoft9c5iF0qZQgv/27lvoBTeg6i5eJ9zrR8Zk2dXjjX\ntFUOYXpeI1pDDmFneI1Yp5vPNW2VQ9g5XiPapBzCznIQbT8OYec5iPYGDuH0yB1ESX2SHpV0V8qC\nbPo4hNOnlTXiVcD6VIXY9HIIp1euIEo6DLgA+Ebacmw6OITTL+8a8avAZ6k1GrYu4hCWQ9MgSvog\nsCUiHqPWej9ts0nrGIewPNSsd6SkLwB/CuwGhoE3Aasi4pN1y8VH5h3y2v2iGwxfcfd6dk7sKWy8\nycwc6OfVid1J5xgcGmDX+ETSOQaGBpio+BxDQ0OMj48nGx9qDYa/fv47Ch2zvsHwnRtfIiKarrzy\ntFO8BrgGQNIZwF/Vh3CfpA2GJ/aw+JJzko0PtbNebrnw+KRzdMKiVWMdaWKcsgGwpJ5qMOzPEc1K\noKVzTSPiQeDBRLU05fNArVt5jWhWAg6iWQk4iGYl4CCalYCDaFYCDqJZCTiIZiXgIJqVgINoVgKV\n6uLmnqPWrbxGNCuBSq0Rfa6pdSuvEc1KwEE0KwEH0awEHESzEmh6sEbSTOCHwGD2786sfYaZFSRP\nz5pXJZ0VEa9ImgE8JGlBRDzUgfrMekKuTdOIeCW7OTN7zMvJKjLrQXk7ffdJWgu8CDwQEW69b1ag\nXB/oR8Re4ERJBwH3SjojayT1BqvXb3ntdtF9TYcGB5i/cElh401m5uAAi1aNJZ3jkINH+NLZRyad\nY3BogMUDi5POMTQ0lKQdYafGh9rfomj1fU3zarWL23ZJ9wAnM0k3t5R9Tcd3TXSkz2UVe2nW2zU+\nwbrvjSadY/7CJUnnmL9wSSV7zCbrayrpLZIOzm4PA+cAj7VXpplNJs8a8a3Araq9lfcByyPiB2nL\nMusteT6+GANO6kAtZj3LZ9aYlYCDaFYCDqJZCTiIZiXgIJqVgINoVgIOolkJOIhmJeAgmpWAg2hW\nAg6iWQk4iGYl4CCalYCDaFYCDqJZCTiIZiWQp1XGYZLul/SkpDFJV3aiMLNekqdVxm7gLyPiMUkj\nwCOS7o2IjYlrM+sZTdeIEfFiRDyW3d4BbADelrows17S0j6ipCOAE4CHUxRj1qty9zXNNktvB67K\n1oz7Sdlg+JCDR5L3BO1EU9vh4aGk40OnmjH3J51jcKA/ebPng2b387Vzjy10zKQNhiX1Uwvh8oi4\n80DLpWwwnLo7NsCiVWNNm+auWfcUS65fzujVl3LK/KNbniN1QKA7mjFLguuSDQ/A9ut2Fz5msgbD\nmW8B6yPihtZL6x5TDaHZgeT5+GIB8AngjyWtlfSopPPSl1YuDqGllKfB8EPAjA7UUloOoaXmM2ua\ncAitExzEBhxC6xQH8QAcQuskB3ESDqF1moNYxyG06eAg1kkZwjXrnip8TOsODmKdlCFccv3ywse1\n7uAg1kkZwtGrLy18bOsODmJi3ue0PBzEhBxCy8tBTMQhtFY4iAk4hNYqB7FgDqG1w0EskENo7XIQ\nC+IQ2lQ4iAVwCG2q8nxD/5uStkha14mCqsYhtCLkWSPeDJybupAqcgitKHkaDP8IeLkDtVSKQ2hF\n8j5iGxxCK1ruBsN5pGww3Alz3jTUUt/Ry65Z1tYcqXWiGfPwcNpmzBqAuC7Z8ECtwXDR2m0wrDxN\nYiXNBe6OiPkNlolbLjy+5QLMutmiVWNERNN3rLybpsr+mVkCeT6++A7w38Axkp6V9Kn0ZZn1ljwN\nhj/eiULMepmPmpqVgINoVgIOolkJOIhmJeAgmpWAg2hWAg6iWQk4iGYl4CCalYCDaFYCDqJZCTiI\nZiXgIJqVgINoVgIOolkJ5AqipPMkbZT0M0mfS12UWa/J8w39PuAfqfU2fRdwiaR5qQurt2HrDs/R\nQ3N0w3NoRZ414qnAzyPifyJiAvgu8JG0Ze2vnc5YnqO6c3TDc2hFniC+Ddj8uvvPZb8zs4L4YI1Z\nCTTtayrpNOC6iDgvu381EBHxxbrlmjdINetBefqa5gniDGATcDbwAvAT4JKI2FBEkWaWr53iHkl/\nAdxLbVP2mw6hWbFytdw3s7SmfLAm9Yf9nbhQqqTDJN0v6UlJY5KuTDDHTEkPS1qbzfOFoufI5umT\n9KikuxKN/4ykx7Pn8ZNEcxwsaaWkDdlr9e6Cxz8mq//R7Oe2ov/mkj6f1b5O0gpJgw0fEBFt/6MW\n5KeAucAA8BgwbypjTjLHe4ETgHVFjls3x+8BJ2S3R6jtExf6PLKxZ2U/ZwA/BhYkmOMzwL8AdyV6\nrZ4G3pzqb5HNcQvwqex2P3BQwrn6gF8Bby9wzLnZ6zSY3f9X4JONHjPVNWLyD/ujAxdKjYgXI+Kx\n7PYOYAMJPiuNiFeymzOp/Q9Q6POSdBhwAfCNIsetn4aEH3tJOgg4PSJuBoiI3RGxPdV8wPuBX0TE\n5qZL5rcd2AXMltQPzKIW9gOa6gvadR/2SzqC2hr44QRj90laC7wIPBAR6wue4qvAZ4GUO/4B3Cdp\njaTLE4x/JPBrSTdnm443ShpOMM8+HwNuK3LAiHgZ+ArwLPA88NuI+H6jx/gD/deRNALcDlyVrRkL\nFRF7I+JE4DDgfZLOKGpsSR8EtmRr9pSX0VsQESdRW/P+uaT3Fjx+P3AS8E/ZPK8AVxc8BwCSBoAP\nAysLHvcoarsIc4HfB0YkNbyY01SD+Dxw+OvuH5b9rnKyTYjbgeURcWfKubJNrXuAkwscdgHwYUlP\nU3uHP0vStwscH4CIeCH7uRVYTW33pEjPAZsj4qfZ/dupBTOF84FHsudSpJOBhyLiNxGxB1gFvKfR\nA6YaxDXA0ZLmZkeFLgZSHK3rxIVSvwWsj4gbUgwu6S2SDs5uDwPnUDu4VYiIuCYiDo+Io6j9He6P\niE8WNT6ApFnZVgOSZgMfAJ4oco6I2AJslnRM9quzgaI34fe5hII3SzObgNMkDal2ffOzqR13OKAp\nXUQ8OvBhf3ah1DOB35X0LHDtvh35AudYAHwCGMv24QK4JiL+s8Bp3grcmv1h+qiteX9Q4PidcCiw\nOjudsR9YERH3JpjnSmBFtun4NFD4xXElzaJ2oObPih47Ih7PtkYeAfYAa4EbG9aTHV41s2nkgzVm\nJeAgmpWAg2hWAg6iWQk4iGYl4CCalYCDaFYCDqJZCfwfM7vEKziGqcAAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def maze3():\n", + " return Maze([\n", + " \"###############\",\n", + " \"#X#@.#.#...#.1#\",\n", + " \"#.##.....#....#\",\n", + " \"#A#.#.#..#..#.#\",\n", + " \"#.a.#C#....#..#\",\n", + " \"#.#.#0C.......#\",\n", + " \"#.#.##.#..#...#\",\n", + " \"#.B...#.2#..#.#\",\n", + " \"#####...#.....#\",\n", + " \"########...####\",\n", + " \"###############\"\n", + " ])\n", + "\n", + "maze3().draw()\n", + "\n", + "def maze4():\n", + " return Maze([\n", + " \"########\",\n", + " \"#@0#.01#\",\n", + " \"#A1#C#a#\",\n", + " \"#0#..#.#\",\n", + " \"#aBc2#.#\",\n", + " \"#B##c..#\",\n", + " \"#..#bb##\",\n", + " \"##1#..X#\",\n", + " \"########\"\n", + " ])\n", + "\n", + "maze4().draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 238, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[]\n", + "[]\n" + ] + } + ], + "source": [ + "print(heuristic(maze3()))\n", + "print(heuristic(maze4()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Assignment 2\n", + "\n", + "Once you have this working, write an agent which finds a policy for a \"blind\" puzzle using MCTS. \"Blind\" puzzles are just like the puzzles above, only (a) you don't get to see the whole puzzle or know the goal states in advance, and (b) some nodes are trap doors with a chance of dropping the player into a bottomless pit! Try different policies for deciding between exploit/explore and for doing rollouts and compare them. Plot graphs on how learning improves with more rollouts.\n", + "\n", + "Of course, it should also be able to solve the earlier maze puzzles!" + ] + }, + { + "cell_type": "code", + "execution_count": 239, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def mcts(maze,iterations):\n", + " # Return the expected value (a number between 0 for \"player dead\", 1 for \"made it to the end\")\n", + " # for a budget of `iterations` rollouts.\n", + " # Should also return the best found path (the one most likely to lead to success).\n", + " # Here, don't look at maze.exit_pos or maze.grid:\n", + " # you're only allowed to query `maze.available_moves()`, `maze.player_alive`, and `maze.is_at_exit`.\n", + "\n", + " # After training for `iterations` rollouts, run an agent through the maze using that learned policy \n", + " # for a large number of times and return the average reward:\n", + " # (best_path, expected_reward, test_reward)\n", + "\n", + " return ([], 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 240, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADgCAYAAAAT452yAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nrkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVQAAAEACAYAAADsjY5UAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nASAJQQWAJAQVAJIQVABIQlABIMn/AKye19Tip1+4AAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOIAAAEACAYAAACu66rqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAEktJREFUeJzt3X+wXHV9xvH3c7n3Zm9yhbE1UCsaoApBhwxQUGpUsBFB\niFqZYQRTnDAMnWA7MLaxIn9U0k4dhOtYOm3JgAqaRuyEJvzstKAMONIRIwRyIT8sUkpQCHFEMikJ\nuUk+/WNPKGxuds/uPd+95+w+r5nM3b2c/X4/u5dnz489+zmKCMxseg1MdwFm5iCalYKDaFYCDqJZ\nCTiIZiXgIJqVQK4gSrpC0nj27/LURZn1m5ZBlPQe4BLgFOBEYKGkY1IXZtZP8qwRjwcejohXI2Iv\n8EPgvLRlmfWXPEF8AvigpDdLmgmcA7w9bVlm/WWw1QIRsUnSV4H7gB3AOmBv6sLM+onaPddU0t8C\nWyJiecPvfdKq2SQiQq2WablGBJA0OyK2SXoH8CngtMmWu+W8E9qrsA1rNmzlU+8+Itn4nqNcc/TC\ncwBYvHo813K5ggj8q6TfAiaAz0XE9k4LM7MD5QpiRHwodSFm/awyZ9bMnT3Lc/TRHL3wHNrR9sGa\ngw4kRcp9RLMqWrx6PNfBmsqsEc16mYNoVgIOolkJOIhmJeAgmpWAg2hWAg6iWQk4iGYl4CCalYCD\naFYCDqJZCTiIZiXgIJqVgINoVgJ5Gwx/SdKTktZLWilpOHVhZv0kT4PhOcClwEkRMY/6t/ovSF2Y\nWT/J0ypjO7AbmCVpHzAT+GXSqsz6TMs1YkS8BHwNeBb4BfCbiPh+6sLM+knLNWJ2nYvPA3OAl4Hb\nJH0mIr7buOyaDVtfuz139iyOnz1aWKEbfu9sZs5K22Nkx44djI2NJZ3j8FnDXHvWcUnn+Mt7N/Li\njj1J5xgZHGDnnn3Jxq8ND7Jrd9rnMPtNNa47812Fjrlx2w42bfvfth+XZ9P0FOChiPg1gKTVwPuB\nA4KYskdk6hACjI6OEl/+o7Yf98Az2zh/1VpWnX8qZxw1u+myWnZ7p+Xl9uKOPcTKtHNo0b7cr1U7\nr89r4y+7nfV353tTXLv+KZZes4KxKy/i1HnvzPUYgHkLl+ZeNq/jZ4++YQV0x6YXcz0uz1HTzcBp\nkmqSBCwANnZSZC/q5H+yfpL69ek0hGWTZx/xceA7wCPA44CAGxPXVQkOYXMOYX55GwxfB1yXuJZK\ncQibcwjb4zNrOuAQNucQts9BbJND2JxD2BkHsQ0OYXMOYeccxJwcwuYcwqlxEHNwCJtzCKfOQWzB\nIWzOISyGg9iEQ9icQ1gcB/EgHMLWUr8+KUO4dv1ThY85FQ7iJBzCfFK9Pg88sw0gaQiXXrOi8HGn\nwkFs4BDmlyqE569aC5A0hGNXXlT42FPhIDZIGcL97/Q2ude/CaZQ5n1OB7FByhDuf6e3A/X7gR8H\nsUHKEKZ6p6+6fg8hOIjJeZ+zOYewzkFMyCFsziH8fw5iIg5hcw7hG+Xpa3qspHWSHs1+vizp8m4U\nV1UOYXMO4YFafkM/In4GnAQgaQB4DliTuK7Kcgibcwgn1+6m6UeAn0fElhTFVJ1D2JxDeHDtBvHT\nwK0pCqk6h7A5h7A5RUS+BaUh6q323x0RB5wiIik+Offw1+4X3WD4iWPOYnS0uPEm040GwyNDh3DD\nx9+ddI7L7h5n5+6kU1AbHGBXwgbDM4YGeXUibYPh2vAgyxceX+iYjQ2G79j0IhGhVo/L1cUt8zHg\nkclCuF/KBsNjY2MdNf9th8byN7Xdr9134hRNbRvt3A3LJ5YnnWPJ0BJuOe+EZOMvXj2e/u+doNlz\nygbD+12IN0vfoOqbQ1Yeea+POJP6gZrVacupDofQipS3wfArwLQfgbj6gXJ0+q9CCO/667umuwRr\ng8+saVMVQmjV087Bmml39RnFHuFqtOzBzU3/e5VC+PG/+njS8e/5m3uSjt9vvEbMqUohtOpxEHNw\nCC01B7EFh9C6wUFswiG0bnEQD8IhtG5yECfhEFq3OYgNHEKbDg5ig35q827l4SA26Kc271Ye1Tqz\npgvnmqZu837JVWm/nrSfzzWtFq8RE/M+p+VRrTXiNJ9r2q7pDKHPNa0WrxET8ZrQ2uEgJuAQWrvy\nfkP/MEmrJG2U9KSk96UurKocQutE3n3E64F/i4jzJQ0CMxPWVFkOoXWqZRAlHQp8MCIWA0TEHmB7\n4roqxyG0qcizaXo08CtJN2fXv7hR0kjqwqrEIbSpatlgWNLvAz8G/iAifirp74CXI+LLDcslbTB8\n2Z1PsjNhQ1voVlPbIXbtnkg6x1BtkIldaZ/HcG2IG8+Zm2z8bvy9RwYHuOET7yl0zJQNhp8DtkTE\nT7P7twFfnGzBlA2Gd+7Z13bD2XbbvGvZ7Umb5kLWODdnd/VOSSJWJp0CLUr7ZrJzzz7SvkqgBEFP\n1mA4IrYCWyQdm/1qAbChgxq7yteisCrJe9T0cmBldv2Lp4GL05U0dQ6hVU3eBsOPA6cmrqUQDqFV\nUU+dWeMQWlX1TBAdQquyngiiQ2hVV/kgOoTWCyodRIfQekVlg+gQWi+pZBAdQus1lQuiQ2i9qFJB\ndAitV1UqiClD+MAz2wof0yyvSgUxZQjPX7W28HHN8qpUEFOGcNX5lTiV1npUpYJYNO9zWln0bRAd\nQiuTvgyiQ2hlk+v7iJKeAV4G9gETEfHelEWl5BBaGeX9hv4+4IyIeCllMak5hFZWeTdN1caypeQQ\nWpnlDVcA90laK+nSlAWl4BBa2eXdNJ0fEc9Lmk09kBsj4kcpCyuKQ2hVkLd51PPZz22S1gDvBQ4I\n4poNW1+7XXSD4ZHBAbTs9o4f/+FvP9RymdrgAItXj3c8Rx61Wg2pZb/Zqc0xBFqUdApGhhOPL1Di\nxqYjCf4MjQ2G88pz7YuZwEBE7JA0C/gosGyyZcvWYLhdWnY76+8eSzrHvIVLWT6R9vLdS4aWtJxj\n84ObuemCm7j0e5dy3OnHdTRHSjuDrjRiLlqnDYbzrBGPANZIimz5lRFxbydFVsE/rfyP6S4huamG\n0IrXMogR8d/AiV2oxbrAISynvAdr+sbnFp2VdPzlt96XdPxmHMLyqvRng5afQ1huDmIfcAjLz0Hs\ncQ5hNTiIPcwhrA4HsUc5hNXiIPaolCHc/ODmwsfsdw5ij0oZwpsuuKnwcfudg9ijUobw0u9V7gs4\npecgWi7e50zLZ9Y06IdzTdvlEKbnNaI15RB2h9eIDXr5XNN2OYTd4zWiTcoh7C4H0Q7gEHafg2hv\n4BBOj9xBlDQg6VFJd6YsyKaPQzh92lkjXgFsSFWITS+HcHrlCqKkI4FzgG+kLcemg0M4/fKuEb8O\nfIF6o2HrIQ5hObQMoqRzga0R8Rj11vtpm3Ja1ziE5aFWvSMlfQX4Y2APMAK8CVgdEZ9tWC4+Offw\n1+4X3WD4srs2sHNib2HjTWbG0CCvTuxJOsdwbYjduyaSzjFUG2Ki4nPUajPYtevVZOMDjNRq3HDO\nuwods7HB8B2bXiQiWq688rRTvAq4CkDS6cBfNIZwv6QNhif2suTCM5OND/WzXm4574Skc3TD4tXj\nXWlinLIBsCRiZbLh63Ms2lX4mJ02GPbniGYl0Na5phHxIPBgolpa8nmg1qu8RjQrAQfRrAQcRLMS\ncBDNSsBBNCsBB9GsBBxEsxJwEM1KwEE0K4FKdXFzz1HrVV4jmpVApdaIPtfUepXXiGYl4CCalYCD\naFYCDqJZCbQ8WCNpBvBDYDj7d0fWPsPMCpKnZ82rkj4cEa9IOgR4SNL8iHioC/WZ9YVcm6YR8Up2\nc0b2mJeSVWTWh/J2+h6QtA54AXggItx636xAuT7Qj4h9wEmSDgXulXR61kjqDdZs2Pra7aL7mtaG\nh5i3cGlh401mxtAgi1ePJ53j8BmDXHvu8UnnGK4NsWRoSdI5arUaUrpe07Uh0KJkwwNw+Gjx57M0\n9jXNq90ubtsl3QOcwiTd3FL2Nd21eyJpH03IemkmnQH0atoGxgC7d02w/u6xpHPMW7g06RzzFi6t\nZI/ZZH1NJb1F0mHZ7RHgTOCxzso0s8nkWSO+Ffi26tshA8CKiPhB2rLM+kuejy/GgZO7UItZ3/KZ\nNWYl4CCalYCDaFYCDqJZCTiIZiXgIJqVgINoVgIOolkJOIhmJeAgmpWAg2hWAg6iWQk4iGYl4CCa\nlYCDaFYCDqJZCeRplXGkpPslPSlpXNLl3SjMrJ/kaZWxB/jziHhM0ijwiKR7I2JT4trM+kbLNWJE\nvBARj2W3dwAbgbelLsysn7S1jyjpKOBE4OEUxZj1q9x9TbPN0tuAK7I14wFSNhg+/LDRpA1tAWpA\n2hlgJPUEdKkZ8/Bg0jmGu9Ds+dBZg/z9WcU2e07aYFjSIPUQroiIOw62XMoGw9cuODrZ2PstXj3e\nsmnu2vVPsfSaFYxdeRGnzntn23OkDgh0sRnzyoTjL9oDV6cbH2D71cU3e07WYDjzLWBDRFzffmm9\nY6ohNDuYPB9fzAcWAX8oaZ2kRyWdnb60cnEILaU8DYYfAg7pQi2l5RBaaj6zpgWH0LrBQWzCIbRu\ncRAPwiG0bnIQJ+EQWrc5iA0cQpsODmKDlCFcu/6pwse03uAgNkgZwqXXrCh8XOsNDmKDlCEcu/Ki\nwse23uAgJuZ9TsvDQUzIIbS8HMREHEJrh4OYgENo7XIQC+YQWiccxAI5hNYpB7EgDqFNhYNYAIfQ\npirPN/S/KWmrpPXdKKhqHEIrQp414s3AWakLqSKH0IqSp8Hwj4CXulBLpTiEViTvI3bAIbSi5W4w\nnEfKBsPdMPtNtbb6jl5y1fKO5kitG82YR4ZBi9KNryGIq9OND/UGw0XrtMGw8jSilTQHuCsi5jVZ\nJm4574S2CzDrZYtXjxMRLd8V826aivTd6M36Vp6PL74L/CdwrKRnJV2cviyz/pKnwfBnulGIWT/z\nUVOzEnAQzUrAQTQrAQfRrAQcRLMScBDNSsBBNCsBB9GsBBxEsxJwEM1KwEE0KwEH0awEHESzEnAQ\nzUrAQTQrgVxBlHS2pE2Sfibpi6mLMus3eb6hPwD8A/Xepu8BLpQ0N3VhjTZu2+E5+miOXngO7ciz\nRnwv8F8R8T8RMQF8D/hk2rIO1ElnLM9R3Tl64Tm0I08Q3wZsed3957LfmVlBfLDGrARa9jWVdBpw\ndUScnd2/EoiI+GrDcq0bpJr1oTx9TfME8RBgM7AAeB74CXBhRGwsokgzy9dOca+kPwPupb4p+02H\n0KxYuVrum1laUz5Yk/rD/m5cKFXSkZLul/SkpHFJlyeYY4akhyWty+b5StFzZPMMSHpU0p2Jxn9G\n0uPZ8/hJojkOk7RK0sbstXpfweMfm9X/aPbz5aL/5pK+lNW+XtJKScNNHxARHf+jHuSngDnAEPAY\nMHcqY04yxweAE4H1RY7bMMfvACdmt0ep7xMX+jyysWdmPw8BfgzMTzDH54F/Bu5M9Fo9Dbw51d8i\nm+MW4OLs9iBwaMK5BoBfAm8vcMw52es0nN3/F+CzzR4z1TVi8g/7owsXSo2IFyLisez2DmAjCT4r\njYhXspszqP8PUOjzknQkcA7wjSLHbZyGhB97SToU+GBE3AwQEXsiYnuq+YCPAD+PiC0tl8xvO7Ab\nmCVpEJhJPewHNdUXtOc+7Jd0FPU18MMJxh6QtA54AXggIjYUPMXXgS8AKXf8A7hP0lpJlyYY/2jg\nV5JuzjYdb5Q0kmCe/T4N3FrkgBHxEvA14FngF8BvIuL7zR7jD/RfR9IocBtwRbZmLFRE7IuIk4Aj\ngQ9JOr2osSWdC2zN1uwpL6M3PyJOpr7m/VNJHyh4/EHgZOAfs3leAa4seA4AJA0BnwBWFTzuMdR3\nEeYAvwuMSmp6MaepBvEXwDted//I7HeVk21C3AasiIg7Us6VbWrdA5xS4LDzgU9Iepr6O/yHJX2n\nwPEBiIjns5/bgDXUd0+K9BywJSJ+mt2/jXowU/gY8Ej2XIp0CvBQRPw6IvYCq4H3N3vAVIO4Fnin\npDnZUaELgBRH67pxodRvARsi4voUg0t6i6TDstsjwJnUD24VIiKuioh3RMQx1P8O90fEZ4saH0DS\nzGyrAUmzgI8CTxQ5R0RsBbZIOjb71QKg6E34/S6k4M3SzGbgNEk11a+hvoD6cYeDmtJFxKMLH/Zn\nF0o9A/htSc8CX96/I1/gHPOBRcB4tg8XwFUR8e8FTvNW4NvZH2aA+pr3BwWO3w1HAGuy0xkHgZUR\ncW+CeS4HVmabjk8DhV8cV9JM6gdq/qTosSPi8Wxr5BFgL7AOuLFpPdnhVTObRj5YY1YCDqJZCTiI\nZiXgIJqVgINoVgIOolkJOIhmJeAgmpXA/wG1t8K8QpVSRwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def maze5():\n", + " return Maze([\n", + " \"#######\",\n", + " \"#@???X#\",\n", + " \"#.....#\",\n", + " \"#######\"\n", + " ])\n", + "\n", + "maze5().draw()\n", + "\n", + "def maze6():\n", + " return Maze([\n", + " \"#######\",\n", + " \"#@?!?X#\",\n", + " \"#.???.#\",\n", + " \"#.....#\",\n", + " \"#######\"\n", + " ])\n", + "\n", + "maze6().draw()\n", + "\n", + "def maze7():\n", + " return Maze([\n", + " \"########\",\n", + " \"#@0#?01#\",\n", + " \"#A1#C#a#\",\n", + " \"#0#.?#!#\",\n", + " \"#aBc2#.#\",\n", + " \"#B##c.?#\",\n", + " \"#.!#bb##\",\n", + " \"##1#.?X#\",\n", + " \"########\"\n", + " ])\n", + "\n", + "maze7().draw()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Assignment 3\n", + "\n", + "Do assignment 2 again, but with reinforcement learning! Compare various approaches and parameters (e.g.\\ different discounting rates, Sarsa vs Q-learning, etc) against your MCTS agents in terms of iterations required to reach certain levels of performance. Plot graphs showing how learning improves with more iterations. Print or draw out (at least some of) the state-value or action-value matrix.\n", + "\n", + "Read as much as you care to of Sutton & Barto---[section 2](https://webdocs.cs.ualberta.ca/~sutton/book/ebook/node39.html) is especially useful.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 241, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def rl(maze,iterations):\n", + " # Return the best path (most likely to lead to success) along with its expected value and a validated value\n", + " # for a budget of `iterations` experiments.\n", + " # As above, don't look at maze.exit_pos or maze.grid:\n", + " # you're only allowed to query `maze.available_moves()`, `maze.player_alive`, and `maze.is_at_exit`.\n", + "\n", + " # After training for `iterations` experiments, run an agent through the maze using that learned policy \n", + " # for a large number of times and return the average reward:\n", + " # (best_path, expected_reward, test_reward)\n", + "\n", + " return ([],0,0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Bonus Assignment\n", + "\n", + "Make an adversary for the maze who is trying to eat the player. Try to get the best performing adversary possible!" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [Root]", + "language": "python", + "name": "Python [Root]" + }, + "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.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From dcd125c1499bdcfe036c3745aa9eed624105b9eb Mon Sep 17 00:00:00 2001 From: erelsaul Date: Wed, 20 Jul 2016 23:09:08 +0300 Subject: [PATCH 2/4] Perceptrons_Erel_SAUL --- projects/6-perceptron/Perceptrons.ipynb | 175 ---------- .../6-perceptron/Perceptrons_Erel_Saul.ipynb | 306 ++++++++++++++++++ 2 files changed, 306 insertions(+), 175 deletions(-) delete mode 100644 projects/6-perceptron/Perceptrons.ipynb create mode 100644 projects/6-perceptron/Perceptrons_Erel_Saul.ipynb diff --git a/projects/6-perceptron/Perceptrons.ipynb b/projects/6-perceptron/Perceptrons.ipynb deleted file mode 100644 index c2e9823..0000000 --- a/projects/6-perceptron/Perceptrons.ipynb +++ /dev/null @@ -1,175 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "from random import uniform, choice\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "def plot_xys(xy_l_tuples,sz=15):\n", - " t_yes = [a[0] for a in xy_l_tuples if a[1] == 1]\n", - " t_no = [a[0] for a in xy_l_tuples if a[1] == 0]\n", - " plt.plot([x for (x,y) in t_yes],[y for (x,y) in t_yes],'go',markersize=sz)\n", - " plt.plot([x for (x,y) in t_no],[y for (x,y) in t_no],'ro',markersize=sz)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "def tuple_append(tpl,elt):\n", - " return tuple(list(tpl)+[elt])\n", - "\n", - "def perceptron(training, epochs):\n", - " # some parameters, maybe interesting to make these arguments\n", - " rate = 1.0\n", - " # how many weights do we need?\n", - " feature_count = len(training[0][0])\n", - " # pad each training example with a dummy 1 input\n", - " training = [(tuple_append(ins,1), label) for (ins,label) in training]\n", - " # initialize weights to random values\n", - " weights = [uniform(0,0.05) for _r in range(0,feature_count+1)]\n", - " # let's store the errors found during training\n", - " errors = []\n", - " for i in range(0,epochs):\n", - " # in each epoch, pick a subset of the training set (just one for now)\n", - " (example,actual) = choice(training)\n", - " # calculate the perceptron activation and the predicted category\n", - " # Note: You can use dot(vec1, vec2) to get the dot product between two sequential collections.\n", - " # calculate the error between predicted and actual and add it to errors\n", - " # update each weight according to the perceptron update rule\n", - " return (errors,weights)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "and_set = [((0,0),0), ((0,1),0), ((1,0),0), ((1,1),1)]\n", - "plot_xys(and_set)\n", - "\n", - "(errs,_) = perceptron(and_set,100)\n", - "plt.figure()\n", - "plt.plot(errs)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "or_set = [((0,0),0), ((0,1),1), ((1,0),1), ((1,1),1)]\n", - "plot_xys(or_set)\n", - "\n", - "(errs,_) = perceptron(or_set,100)\n", - "plt.figure()\n", - "plt.plot(errs)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "xor_set = [((0,0),0), ((0,1),1), ((1,0),1), ((1,1),0)]\n", - "plot_xys(xor_set)\n", - "\n", - "(errs,_) = perceptron(xor_set,100)\n", - "plt.figure()\n", - "plt.plot(errs)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "noise_chance = 0.0\n", - "N = 100\n", - "xys = [(uniform(0,10),uniform(0,10)) for _r in range(0,N)]\n", - "secret_f = lambda x: x*2 - 1\n", - "dataset = [(xy,(1 if (secret_f(xy[0]) <= xy[1] or uniform(0,1)= 0 else 0\n", + " error = actual - predicted \n", + " for i in range(0, len(weights)):\n", + " weights[i] += example[i] * error\n", + " errors.append(error)\n", + " # Note: You can use dot(vec1, vec2) to get the dot product between two sequential collections.\n", + " # calculate the error between predicted and actual and add it to errors\n", + " # update each weight according to the perceptron update rule\n", + " return (errors,weights)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAEACAYAAABWLgY0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAEACAYAAABRQBpkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "and_set = [((0,0),0), ((0,1),0), ((1,0),0), ((1,1),1)]\n", + "plot_xys(and_set)\n", + "\n", + "(errs,_) = perceptron(and_set,100)\n", + "plt.figure()\n", + "plt.plot(errs)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAEACAYAAABWLgY0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nXpIaZuQlqWH/B+0+jLk322bvAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAEACAYAAABRQBpkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n5OM4zVYAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "or_set = [((0,0),0), ((0,1),1), ((1,0),1), ((1,1),1)]\n", + "plot_xys(or_set)\n", + "\n", + "(errs,_) = perceptron(or_set,100)\n", + "plt.figure()\n", + "plt.plot(errs)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAEACAYAAABWLgY0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAEACAYAAABRQBpkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJztfXusbUd93vfb5+nrxwUSuAH8aIyJSRw1xopcU6g4AjsY\nh9iugihuZXKttkJV3ZK2qmynUXwtRQr5o6oSmTysusRGDaRJlWBTAubRU0ISqHnJED+Ja2Ku4Qbi\n3Ovcx3nsc6Z/zB7vddaZ95pZa9Zav086Ovux1uxZ8/rm9823ZpEQAgwGg8EYNyZdZ4DBYDAY3YPJ\ngMFgMBhMBgwGg8FgMmAwGAwGmAwYDAaDASYDBoPBYCARGRDRvUR0jIgesRzz60T0FBF9jYguT/G7\nDAaDwUiDVJHBBwG8zfQlEb0dwGuEEK8F8F4Av5XodxkMBoORAEnIQAjxeQB/aznkBgD3z479IoCD\nRHQoxW8zGAwGoznaWjN4NYBnK++Pzj5jMBgMRgHgBWQGg8FgYLGl3zkK4ILK+/Nnn+0DEfFmSQwG\ngxEIIQQ1OT9lZECzPx0eAPAeACCiqwAcF0IcMyUkhNjz95nPCFx2mdj3uevvVa8S+PM/Dz+vlL87\n77wz6Pibbxb45V92H/fzPy9w5Ij+u4svFvizP8t/bc8+K7C0pP/u3nsFfvZn48uh739XXCHw8MPy\n9X33yXoNKYszZwQAgRMn9n93//0Cb35zeJ6WlwWeemr/55/4hMDll4end8EFAl/60v7PH31U4HWv\nm7+/5hqBT35Sn4ZPWfzN3wgsLHRfp4cPC7z//WHn/OmfCpx/vv67224T+JVfmb9PgSSRARH9LoA1\nAD9ARH8F4E4AywCEEOIeIcTHieg6IvomgFMAbglJfzoFNjbC87WxEXdeX+F7vdOp/DN910aZbWzY\n82D6bgzY2ABWV+XrxcXwslDHb2wA5523P+3Q+t3dBba29OfZ6tEG03nTqbxmhdXVZu1xOgV2dgAh\nAGo0b26GmHKy1VW1jaRCEjIQQvxTj2NujU2fycAPfSMDIeRAM6nFp0wGwMqKfL2w0IwMdGmH1u/m\npj291GSwsDB/v7LSnAwASQiLbYniGuQgA9VGUqEXC8jT6bxBhmBzM+68UrC2thZ0vO/1usigjTJT\nv2EaEKqfh5ZD37G5aY4MfMpCHa+rx5g+oY43pRdDBqbzdJGBKb8hZdH15CKmnGx1VW0jqdAbMgid\nHajwsM+RQegg2LfIQP2eLg9jJgObTBQyAKaKDNTxqSIDJTs1lYn6RAaxkcH2thzHdN8xGXjC1oCH\niqGSwdiQcs1Al3bXZOCKCqtkkEom6ro9xZIBoI8ORisT7ezMZ/q+sIW2Q4WvBLCzYy7LnZ12ZSJd\nPmz5GwM2N+cdfXExvCzU8W3JRKH5c9W9r0zkA/UbXbenJuVkKvfRRgZAWKPgyMAMjgzKhZr0LC3J\n90OMDFx1n9pNZPqtNtGknEzlPmoyCGkUTAZmMBmUCzXjUzbIXGQQYk3vkgxYJjKX+yhlopjIgGUi\nM0yDrRDty0RMBntRlYiAZtZSk7wgRFiaqd1ErrqvWkubykSlkEGTcmKZqAKODPzQNDJQmiZHBt2h\nHv7niAxM39nyZEuPZSI3WCZKBCYDPzQlg5hyjgWTgR5MBkwG1XOq/+vfjVImsrkjTBibTCREczdR\nTDnHgt1EetRlohxuItN3tjzZ0svpJlpZYTcRy0QVcGTgxva2JASODPqNPkYGu7vyLzS9sUQGqj2z\nTJQATAZuhFwvk0G56CMZAGGz3rGRgW3B3AaWiTSIdRNNJuORiUKu10UG7CbqDm24iUL7he2cmIEu\nxE3UVCbqMxm4yp0jA09sbAAvecm4IgPf6+XIoFy0ERmE9gvbObZ6tKVnOmeIkUFMGanzdOU+nUpZ\nLvUurIMmg4MHx0UG553nd0MRk0G5aIMMQvuF7RwmAzeakIGu3FX0mPr5DL0gg1g30cGD45KJzj7b\nT1ZQez3pPldp5YYtdGY30fx9DjdRaL+wnWNzBtnSA8x1PzQ3UUwZAXMyqF9/DokI6AkZsEzkhppR\n+sykplN9w+wiMjDlgyMDiSHLRKa658hAYnNTX+45nETAwMlgbDLRyorfXi4sE5ULlomYDKrn6co9\nh5MI6BEZhIaLY5SJVGTgumYbGTQNy32h5BAmg71I5SbS1aO6MfG889LKRKZ6tKW3vDwuN1FoGQEs\nE2kxnUo9nGUiM0JlIlNHDC3nWGxsyN8y5SP0RqahIFVkoKvH7W2ZXsq+ZKtHW3rnnDOuyCC0jACW\nibSYTmXjYTIwIxUZhJZzLFwDAjDOReRUZKCrx5A2Uj/PRgamerSlNzYyCC0jdZ6JDEYrE+3syMIM\nfbjNmNYMVCjqs2ZgcxO1RQabm+YOUoIDpCvUJYAYMjDVY8i6Uv08XV9SslPKyMDkJgp5/kI9PaB7\nmeicc+LdRBwZVBAjX4xtzaA66/NZMzA5Oc4+u50yU6GzzdU0xnWD+qxvMpF+8hDJzFSPIetK9fN0\nfWlrSz6RbWkp3Fpqq/sqGUwm8v32tn/69fSAbicWTWQiXjOoIXbN4OBB2WBjZxV9QiqZ6MABWWa5\n9XrXmkH1/5igm/WFRgem/pJaJlLphebPVff1O2ubSEUltKUYMlDR+7nncmSwB0oDDZWJVlflrGUM\n0UGITGQjg6WldhxFNpmohA7cFXSzvlBHkW3NIKVM1IQMbHVfdRMBzdpjCW3J1tZt56ys6Ilw1GsG\nsTJRTEjcV4TKRLZZWRtkwJGBHrqOHhsZ5JaJ1IAVmj/bOgNHBhK2uhq9TBTjJooJifsK3+tVz7+1\ndcQ2yszHTTRWMkghE6V2E51zjpQOq/nIFRkMkQxiHFemumKZKEImigmJ+wrf61VrATYnR24yUHsP\nnXWW3U3EZCAROtjmcBOtru6PGHOQQd1NBDTrw30mA1NdjVom2tlhmcgF3+u12TaVXptbJqrKCzY3\n0VitpTqZKKQscshEuvNUXhcW8rmJgGZ9uASbsu16beewTKRBrJuIZaL9UJ2tS5nINaO05XHoSCUT\nrazMJcF62jEyke68vriJum5LMWsGLBMZwDKRG77XqwaK0skgZi+XIUDX0WPcREtL+sE7VibSndem\nm6gJGXTdllgmSgh2E7nhe71qoAD230vQlpvI5UIpoQN3BZNMFEoGunqM6RPqLmNlc9TJRG24iZpY\nS7tuS7F3abNMpAG7idwIlYl0HbikyGB1dZxkkEom0tVjTJ9Qm9stLKSVidp0E3XdlmIigypxs0xU\nActEboTIRCYyaMtN5BpEdna678BdIZWbyEQGoX2iKkm0IRPlcBN13ZY2NuSd/YD/nf0sExkQ6iZS\nfujlZZaJ6lCdzRQZtOkmMmnhqgOzm0gixk2kq8cYmagqSaRwEynZ6cCBdmQiNbHo2k0UWk5VO299\nS53Ry0QhZKAKn4hlojqqkUG9YXYhE5nshV3P5rpCaTJRNT8pZCIlOy0vh1lL+x4ZhJaTGvAnE7nG\nt7W1P73U6BUZ+G46Zwtth4oQmWhhQT8rL2nNoOtFv66Qmwy6lol8bcVVDMFNFFNOtnIfrUykJJ86\nQ5pgC22HihA3kc8Ccm6ZiMlgP4SQM+d6R4+xlurqMYdMFDPjdTnJ6tbSIbiJYkkTMJd7avSGDJRV\nzmeGYAtth4qUbqLc0ZSa2ejyIISUD7ruwF1gc1NOeIj2ft7EWppbJgq1lsZEBkOQiULLqU7CunpM\njV6Rge8MgWUi83Glu4l2d6VOanpg+pBh6uSp3URqrcZnMbNtmUjnJhoCGbBMlAihgxTLRObjfNxE\nXcpEtgXuocMU/sdEBrp6VOkrY4VPHXchE+nWDJq6iUqQiWLcRADLRHtQtcqxTKRHSjdRWzKRrnPY\nIpehwzTji7GW2mQiwL9f+MhEMYOc6ZxcMlHXj71kmSgRWCZyI1QmKtVNZHM7DR2pZCKXmwgIm1h1\n7SZqSgZdrz+xTJQQoYPU2CKD6VQuvPqUkRpsu9yOwlcmGhsZmML/1G4iIL4vNZWJXLNknZuo6WMv\nuySDqkOM3UQJECpfjG3NIEQL9nUT5Swz24AwZjKwyUQp3URA/JpBUzeRj614SAvIVYcYy0QJwDKR\nHSHX63ufQZcy0ZjJgGWiYZFBtU5ZJkqAnR39rokmjE0mCgn/bW6i0HJuml+bvZXdRHPEWEttu4wC\n6RaQU8tEpo3q+uomqtZpEzeRKvfdXXnjbbFkQETXEtHjRPQkEd2m+f7NRHSciL4y+/tF37TVLn+T\nCctEJoSE/75uojZkInYT7UUON5FtzSCFtTTUTeSyWQ7NTVSt0xRrBooI6jcmpsCi+xA7iGgC4G4A\nbwXwHICHieijQojHa4d+TghxfWj61cYRIhONKTKoh6Jq19Z6pwJYJioZbchEJUQGLBO5YYr2c0lE\nQJrI4EoATwkhviWE2AbwEQA3aI6L4rI6GTTVOYeI6rbHRPaZvc26WYqbaKzW0hxuohLXDMbkJqrW\naYo1g1yLx0AaMng1gGcr7789+6yONxDR14jofxHRj/kmXiUDlon0qDcQ2zWzm6hc5HATtSETxcx4\nFcHVdyEe2n0GqWWiXLZSIIFM5IkvA7hQCHGaiN4O4I8A/Ijp4CNHjrz4+oor1rC4uAaAZSITdGRg\numaWicrFmGSiyUT+7e7ujQRYJpKwyUSrq8D6+jrW19eT5jUFGRwFcGHl/fmzz16EEOJk5fUfE9Fv\nENHLhBDP6xKsksH3vhcnEx08KF+PTSYC7NfMbqJykdNNVL0xEehWJnrpS+VrdV6VDNhNJFEv95Mn\n936+traGtbW1F4+/6667Guc1hUz0MIBLiOgiIloG8G4AD1QPIKJDlddXAiATEdRRbSy+gxTLRM1k\notxlpvJrW7cYa2SQ0k1kkxdSyUQ2Z5ArvXr9q+3Ldc8z6LObKHbNoHcykRBih4huBfAQJLncK4R4\njIjeK78W9wB4JxH9KwDbAM4A+Ce+6dfXDE6dcp/DMpGfTNT1RnW2PCwu+tX1kJBaJrItPDaViYRw\nLwa70qvXvyKCum2y7zJRzJqBSybKgSRrBkKITwC4tPbZb1defwDAB2LSZjeRG/UZpe2aVXmWsFGd\n+s16HsbqJtrYAM49d//nKdxEIW2kniddX5pO51ssxLpk6ufpnETqOCHMdmkbSlhATu0mKtlamhUx\nZFBlVaU3+jw7ua8IkQBUh/NxE+UqM96oTo+UzzPILRPFWiZt59kG+1jpsmsyiCknIfauA7YlE/WK\nDHwXkupsPJkMe2BJ7SZSM/Pt7Xz5ZWvpfuSwluaSiVJYJkPJICZa7aNMtLUln/Q3mY3ObclEvSKD\nGJkIGL5UFCMT2dxEQF6pyOZCsbmdho5UawY6N1FqmSiF/FE/T+ckCs1vHSWQgWnB3HaOqa5GLRPF\nDFCxIXFfEXK9rsdehm790SS/LjcRW0slSpGJVlZktKhkjNBBrp5e/bzUMpEQ8j6GkmQi3+dOm+qK\nZaIIb3RMSNxXpHYTAfmiKTWQLC+73URjjAxyPfYyhUxEJOttc3P/DD9mN876eallIjWRXFrq10Z1\nOuJmmQhxs1WWiZq5iYB8BKqIYDIxRydjdhPpOnopbqLqeTlkIpObKCS/VdjaeluIKSeWiQxo6iZS\n57FMJOHjJnKlkSqvvIC8FylkouqW78vL8rzd3TQyUfW8PriJbG29LcSUE8tEBrBM5EZqNxGQL5py\nhc1jJoMUbqJqHdZlnaYyUfW8PriJSmhLMeVkqyuWiVgmsqJPbiJX2Mxuov2fh5RFfTsH3eANdCsT\nmc5L7SYqhQxCF9pte42NWiaqNhCWifTok5tIt3FX9eY2dhPt/zw2MgD0sk71c1da1c3tTOmFykS2\nNYOUMpFq68qvryS0NsFuooSoLiqxTKRHn9xE1ZkN0XwbY13+xhgZNHUT1QdU3Uwe8OsTauCp7hWk\nizRin+1bPy+XTAR0N7lgmSghQmer1Q20FFgmmqNrN1G9MZscJewmmqNpZBArE+nIKadMZCODJjIR\n0F17iiknlokMCB2gtrakr3hSubKhRwY2X3IdvgvIOa2lLjIYa2SQ4rGXITKRDxnU89NEJqrLTiHW\n0lg3kem32kIKN9HioozOplOWiYKkC11hDX3NwKYx1uFrLc316Mv6zIbJYI7UbiLALhO56tfUl2Ld\nRL4TAR1iZSJFLl21pxQyEbC33JkMsJchTbCFtkNFX91EgNlRMjYy0MmbCl25iVLLRL51r0NTmahL\nMmjqJgL2lvtoZaJ6A3ENUjZWHSpCJIAQN1HXMtGY3ETViK2OVGsGqWSiJmTgExXq0MRNFJLH1Ejh\nJgI4MgCwX0d0NWKWidwyUZfW0npeTZuVjS0ysHXyJm4i05pBddM5E2x9KebZvvX0Qjeq66ubqGkE\nBZjrMSV6QQZ1DdQ2SLFM5C8TVTvH7q78UwvvbVhLgf35GDMZmML/VGsG1fSJpNEiti+l0MJNda9D\nCjLoy5oBy0QGmMJeE1gm8nMT1WdlKqRWnvIuZaIxWkttM76mbiKTvNCkL+WSiWwb1TVxE3XVnlK4\niQCWiQCEkwHLRHFuIpO8kDuv7CaScMlEqa2l1e9M8JWJ2E1kBstECcEykR27u/PH5CnEuInqLpQ2\nZSJ2E6WTiUz1GNMvfGUiNet2PTO7iZuojzJR3SHGbqKGYDeRHVtbsnHotgzQwTTYhkZgsWA3kR62\nGV8ON1H1OxN85YrJZP+2Iqb0Yt1EMTJR126iquSp8sBuogZgN5EdtpBSB1Nk0JVMxG4iiT7LRIDf\nrLdrN1Hb7ckVCfmeB7BMBCBOJhpTZBB6vaaZt8mFkiO/7CbaD5dMlHqjOqB5ZGCrR5/02nYTtR1p\nuiIh23m6cj9zZuQyUYybaExrBjZ9UQeTm6gkmYjdRHuRyk2Ues0gdNY7NjeRq63bztOV+8mTe2Wn\n1BgcGbBMZL+hqDSZiN1EEn2XiXzy2IWbaEgy0YkT+SQioIdkwDLRXuiut/q4wzpM1tL6Qj27idpF\nSjdRVzKRT2TQtpuoS2tpapno+PGRk0GMm2hMMpFpEDFds81NFLJQ3yS/7Cbaj5SRgc9GdUCZMpHN\nTRTaHrt2E+nMEr7bdujK/cSJfOsFQA/IgGUiO0xas+mau5aJ+HkGeuS0lg5FJurb8wxi1wxYJjKg\nPtNhmWgvTDNK0zWX5iYyPfpwbAvIOd1Ep0/LNaTqjYlAWpnIZ9brmimzm2h+HstEGrCbyI5Qmahr\nN5GPTLSw0O1DzLuATSZq6iZ64QVJBNUbE4EyZSKbm6gJGXQxuYhdQGaZyACWiewYqkyk+27IyCkT\nmeQFlonygmWixAgdpFgmkrDJRL4b1XW5gKz7bshwRQY7O+69fwB9PZrkhViZ6NQp+TtLS/PPU7iJ\nbGSwvCylrpBIsQQ3UUoyYJkoUMtmmUjCJRPpbH0lbVSn+27IsK0ZqL1/fDRvXT2a5IXYvvTCC/v3\nw0ohE9mspTa7tAldTyx06yquPAjBMpERKTaqW1qS6QzRqmiTiUKtpdVyXlyUDTN1BwqViYZYZzq4\n9pzxHcxMawYpIwNderkjA/XbIWTQ9cRC19Zd7Xk6lcRXLwdbPaZC8WSg802H6pxEw103sMlETdYM\ncpWZzlHCMpFdJgL8iVFHBkKkXTPQpefjJmqyUZ367ZBoteuJRewiu6muTPWYCr0gg6Yykc95fUUT\nN5HL1pejzHRSQT0fivzHZC+1yURAfGSg0kwpE+nSi5WJfK2lPvmtowQ3Uai1VCcRAfZ6TIXekUFM\naOtzXl8RIhMJMdeUfUL01GWm00N5AVnCJRP5Dma6/lL9X0VMX1JtJ5dMZNuELTRS7botxbiJbONX\n9X8O9JIMQkNbn/P6ihCZaGdHLkQqTdKHDFKW2XQqf7++NsFk4CcT5SCD2L4UQwZNrKXqd0Mjg765\niZgMLGCZyI6Q67UNtHUXiimN1HllN5FEKplI5yaq/q+iSV9KJRP5uol88ltH1xOLGDeRrcyr/3Og\neDJI4SbyOa+vCJGJbANtGzKRLq/sJpLI5SaaTKSbLpVMpM5jN5EbMW4iW3+u/s+B4skghZvI57y+\nIkQmqi+oVW9kakMmMmnQLBPlk4kA/eCtPk8lE+V+7KX63b5FBiwTJQTLRHbEykREsjOqOzrbcBOZ\nZCKTo2RsZOCSiWKspYBe1lGfm+p3dxfY2tq/uZ0pPZ/8dekm6spaGvPMB5aJDGA3kR0hMlG9LKsz\ns5JkojFaS3O5iQB7ZGCqX+X6qm9uZ0qvdDdRCY+9VHmwbSvCMpEF7CayI1YmAvZ2xq5kInYTSZQm\nE9nIqU9uopJkIrWtiG1/JZaJLAiRiRTr6hoUy0T7Z17VDsJuom6Ry00ExMlEtvzEuIl0slMbbqKu\nraX1cnJFKKZyV5sCjlomCnET2WZXLBPtL0ufyIDdRO0gl5sIiJOJXH0pNDLQyU5jcxOpfNjatKkd\nqO1hio8MiOhaInqciJ4kotsMx/w6ET1FRF8jost90643kKUl+Zku1HKFtiwTsUxUKoYuE4VOBEy/\n22eZyCcfoSScEo3JgIgmAO4G8DYAlwG4iYheVzvm7QBeI4R4LYD3Avgt3/Tr0gaR+dGXrtB2iJFB\nrJsI2DtL6cpNZNsjaSxkoHbUtQ2EbbuJQmUi10Z1JlvxmNxEKh8xMhFgrsdUSBEZXAngKSHEt4QQ\n2wA+AuCG2jE3ALgfAIQQXwRwkIgO+SQeIl+wTDRHH91Eu7vyTz3ycixuIlUuOueOQg43kRpcde6W\n1DKRz8A4dDcREBdBKeSODCw87I1XA3i28v7bkARhO+bo7LNjrsRD5ItYmejrXweeecaVkzIR8kjD\nlDJRTJl98Yv2zqEWP9WgqOs4f/mXwKOPhv1u6Th50t3Jc8hEi4vzQbL61DKgXJnoq18FHnxw/3eT\nCXD11XsJJzTK/JM/kU8TSwXdk8l0+fjyl4HnnpOvH3kEeO1r9en1gQyS48iRIy++Pn16DYuLa3u+\nX10FzpzZf54txFpdlY/r0+HwYeDss4GDB6Oy2ymuuQZ42cv2f64rI5ebqH6D0eoq8Hd/p//dW24B\nDhwIL7Obbtr7vp4HE1kp3HEH8PTTwCtfGfa7pePmm+3fN3ET3Xgj8PrX649X7aROBra+dO21wMtf\nHpa/UCeZDm94A/C5zwH33LP/uy98AfjwhyUhKIS4iXZ2gLU14LrrzMeE4i1vAX7wB/d+potQ3vlO\n4DWvAc46S75/05v06R0+DFx8sXy9vr6O9fX1dJlFGjI4CuDCyvvzZ5/Vj7nAccyLqJLB3XfrNVDT\nmoGJOVdWgOef13935gxw//3AZZeZctQ/6MrI5SY6cGB/Gt//vj79M2eA3/kd4Md/vFk+bdGJTuc9\ncwb4pV8Crr++2e/2DU0iAxvRxPSlG+oisEf+Qs0DOrzpTeaB8h3v2D/5CXETbW7KyZAu6kgJU5v+\n0IfcE5zbb5+/Xltbw9ra2ovv77rrrsZ5S7Fm8DCAS4joIiJaBvBuAA/UjnkAwHsAgIiuAnBcCOGU\niIB2ZCKXra+PyC0TpSozFxnUO/AQ68oHTcjAhpi+FJO/FDKRDa723kSrT4mS23TjyEAIsUNEtwJ4\nCJJc7hVCPEZE75Vfi3uEEB8nouuI6JsATgG4xTd93aJS6gVkl62vj/BZQG5yn0GqMrMtYus6zhDr\nygdN3EQ2xPQlHWLdRCnJwLVle2j+cqDkNp1kzUAI8QkAl9Y+++3a+1tj0g6xPMZaS0upjJTwsZZW\nO3CotTRVmdXtrVXi1+mrQ6wrHzRxE9kQ05d0WFwETp82f++7SaHNTWSDiwx87vztggx0T//rCsXf\ngRwyY20iE5VQGSmRKjLIXWahMlHoIDUU9F0mSrFmYEPow5x0+WujXdXzsbUlP5sUMBIXkAUzqs/s\nrcLUgFkmmiN0zcBUzm1EBiFuolL01bbRxE1kQyqZKMWagctNZENf1gzqEUpJ7bloMqj7zhVSykSq\nYmIbYanQ3VBks5aGyETTqbw5LEWZxUQGpXSeNpErMkgpE6W46Sz1moGvtbQrmaik9lw8GegaR8oF\n5KHKDgsL8m97e/5Zqo3qbHvdhyLUWjrU+nIhp0zURmTQhUwUYi1tUyaqtumS2nPRZGBaUEppLS0p\nTEuN+jWnWjNIWWahbqIh15cNOd1EKerY5SbSpZfaTeSSiWJ2C02NepsuqT0XTwa6xpFSJiopTEuN\n+jWnchOlLDN2E/mhD26i0Jm3euxq9TncY3MTldSee0kGLBP5oX7Nqe4zSFlmIWsGyoaney7v0DFE\nmUg9h9s2IfFFX91EJY0/vSUDloncCJGJQlxbKcssxE2knpRVgg2vbeR0E3V1B3L9PHYTdYuiuxXL\nRM2gk4lSuIlSy0S+kcGQ68qFIbqJqufVty8PBbuJmqNoMmA3UTPUrzmVm6hNmahU50XbGKJMVD1P\ntc1Yhxq7iZqjaDJgN1EzDM1NNOS6cqH0O5BdC7Sm9NR5TdYLgP7IRCW36eLJIFQmMhXs8rIs+PpT\nnUoK01LDtYDsWrxbXpY6ff150125iYZcVy7kspamlIlcG8GZZKKdnTRk4HITlbhRXUltupdkECNf\nTCZzQvA9p+9wWUtdkYHpedNduYmGXFcu5LKWliITNbGVAuwmSoHekkFMaKs7r6QwLTWauol0aQDd\nuYmGXFcuDN1N1MRJBPRHJmI3USRSykSm80oK01Kj6X0GQP4yYzeRH4buJkotEylpU7mT2E3kRtFk\nEOMmsjVg3XklhWmpUe/o9VmjDxnkLjN2E/lh6G6ipmQQ0tZN+evKTcRk4IHQNQOWifaiqZtIlwaQ\nTyZiN5EZPmQgRLj2XopMlNpN5GpLvvlLDV2bLmWCUzwZ6Bp2zEO81XksE83flyAThVhLh1xXLvi4\nidRNWyE3bqWSiXzcOrr0UlpLXW2d3UR2FE8GLBPFo+lGdUA7MlGItXSodeWCj5soZkAtQSZS1tKU\nbiJdWy9FJmIyiADLRM0QGhl07SbiyMAMH5koZkDV1W/Mc3lLWTOo7oCqI4P6fUau/KVGyROc3pJB\njExkmuX7JFOpAAAVQUlEQVQOdYAJtZaGRAapymwyme9Lw9ZSM3zIIMaeqavf7W2ZTgixdG0tVfk1\nTSyUfFa/gdKVv9QouU0XTQamBhKrc5r071KYOTVSuIlylxmR+S5UdhPN4RsZhA6oqeq3a2spsPda\ndPdb2PLIbqLCySBEJtrdlcfb9rpnmag8N1E1HywTmZGLDFLVry1/NtkpJRlU27suPRcZdLWAXMoE\np3gyCNGxXc/lZZkojgxyl5nJUVJySN02fNxEqRaQY+rX5iayyU6p3ETA3vZuIgNTHlkm6gEZ6BqI\nbtM5H4Ydu0wU4yZqo8xMjpKSF9vaRi43URsykS29VG4iYO+16MrCVobsJuopGUwmwNKS3FFTwYdh\nWSZimaiv6LNMZKs3lonKmeAUSQauAQrY34h9KpNlIrubyCTJ5S4zk6Ok5JC6bfi6iWKspSnq15Y/\nW72lchMBfjJRTB5TgjeqC4SqUFsDqYe3Pg14bDJRvaOHPukMaE8mMkUG7CaSyBUZqDJuWs5NZKJc\nbqLQyIDdRAXCFuop1Ac6n5tkxiYT+T4Dub7DYxUsE5WBXGRAtL+OhyIT+VpLY26yiwXLRIGohnqm\nsLdOBiwT7YevTBRCugC7ibpALjIA4vpSHbbFWVu9te0m0uVxa0uaUkL2dIpFyW26SDLwiQzqm9Wx\nTLQfrgVk5SZylTO7ibqHayM4IH5A1UmuMTKRKX8luYl0eWyzXZUc7faWDHSzGR+ZaEyRge9jL7uO\nDFgmcqMPkcHOjn7vn9LdRG22K5aJAmEL9RR0awZsLd0LX5nI5kJpc82A3URm5HITAWnWDIjMM+/S\n3URttit2EwWibZmolMpIDd/7DGJkIo4M2kXOyCCFTATYZ95tuIn6Fhmo/02vOxWKJgPbbCGlTFRK\nmJYavhvVxchEbC1tF6XLREDcYJvTWurrJmp7zUC16dImN0WSQVsykc/mdn1GisigXmZCyL1m2iID\njgwkcpNBU5kI6J4M+hYZlDa5KZIMbF5hhRQykc/mdn3G4uL8ubiA3k0UKhNtbkryTFlm1XzY3EQl\n6atto3Q3EWBfMzClZ6r7GLjWDGLWNFKjSgaltefiySCnTFQaM6cG0V7SNMkwqcs5FKZ8lOy8aBtD\nlolcbdAXLmtpKTJRNTJgMnCgLZmoNGbOAVvoHOMmylFmvm6i0jpPmyjdTQQ0k4lSuYlKl4mq0W5p\nk5siyaAtN9EYBhdb6BzjJspRZj5rBm1uGVAi+uwmstVb6jWD0q2lLBMFoi03UWnMnAM2h0WMmyiX\nTKTLR/VGpul0/ojMMWLIMhG7icpA0WTAMlFz+MhEIW6inDJRPR/qRqbd3fI6TttgN5EbfZCJ2E0U\nCJ+N6lgm8kMfZCKbq0nlcQzEbUP9ngsdupaJmrqJ2pCJ2E1kRpFkEOsmCt21tDRmzgHbbMlno7q2\n3UR18leDxRjqyobJREZIartxHfoqE3X92Et2E0kMhgx8FhdVNKE20yqNmXPA1kF83ERtlJnNUaK+\nK63jtA3b3j8K7CYqXyZiN1EgfKylMfLF4qLsVKUycw40lYkWFuTf9rZ836abqPrdGIjbBde6Qdcy\nEbuJ3GCZKBC+bqLQNQN1nkq/NGbOger1mnz8ro6Yu8xcZLCzM466ciEXGXQtE+VyE5V601mpbqJG\nxU9ELwXwewAuAvAMgHcJIU5ojnsGwAkAuwC2hRBX2tLNJROp8zY3gXPPLY+Zc6AuE4VaS4G9xNum\nm6j6XWkdpwvkJIOuZaIcbqIQaym7iZpHBrcD+LQQ4lIAnwVwh+G4XQBrQojXu4gAyPfYy/p5Yxhg\nVEdXi4/VR/vFRgbsJuoGpUcGpgXa0h97yTKRRFMyuAHAfbPX9wG40XAchfxWrjuQ1XljlIlU2Fzd\nYM7HTQTkLzN2E/nBtYBcwppB6GMl23YTlfTYy9Imo03J4BVCiGMAIIT4LoBXGI4TAD5FRA8T0b90\nJdqGTKTOKakyckB1ENtMyeVCaUsmYjeRHa7IgN1E/XMTldSmncVPRJ8CcKj6EeTg/ouawzVPQAUA\nvFEI8R0iejkkKTwmhPi86TeffPIIjhwBvvlN4BvfWMPVV6/tO4ZlIj+ojm7rHF3LROwm8oOPTHTg\nQHi6uReQfR57OVaZKDYiWV9fx/r6erJ8AR5kIIS4xvQdER0jokNCiGNE9EMA/tqQxndm/79HRH8I\n4EoARjI4dEiSwWc+A/zkT+qPYZnID3WZqAp1I9PWVvcyEbuJ3OirtdQlE7GbKBxra2tYW1t78f1d\nd93VOG9NZaIHAByevf45AB+tH0BEB4jonNnrswH8FIBv2BJlmSgdqjJRXUJQG79tbrKbqA9ow000\nncobDGPS6dpNtLQ0X3/oi5uopDbdlAx+FcA1RPQEgLcCeD8AENEriehjs2MOAfg8EX0VwBcAPCiE\neMiWKLuJ0kFdr6mzLS7K70t3E42hrlxow02kyD7mSXa27R7acBMR+cmiIflLjepOvKVFu42KXwjx\nPICrNZ9/B8A7Zq//H4DLQ9INdROF7HU/RpnI1DkA2ThdkUEbMtGpU3Y30ZifZaDQhpuoSf2a3ES+\ndyA3dRMB83EhxE3UZtuqbitSmjJR9B3IvjLR9rYMESceVzM2mcgnMtjc7N5NtLPDbiIX2nATNalf\nXf5cspOt7mNga+8lRAbAXrt0SW26t2QQO5sZm0xks5YCZchEvGbghzZkoiblrMufSs8kO6VcMwD6\nQQbVNl1StFskGahZim22oG6gCh0oxioTmcrShwxKcBOxTNSOm6ipTFTPn6veUpOBkolC3ERtt61q\nmy5pglMkGWxtScujr/89hAzGFhn0YQGZIwM/9DkycJ0z1sigpDZdJBnYFoGqUBUfwuxjWzOwWUsB\nfzLIvWawtSVf19d9Su04XSBnZLC9PTdiDIUMSrSWVvNRmjJRJBlUHTC2BTE10LFMZIaPm6hrmUjl\nQVfX7CaaI5ebiEgaMDY3m9WvLn+ueqtaS7twE4U4EVNBkUFpk9EiycC16KmgBjqWicxI5SbKLROZ\n7K0cGczhExnEDqgxkqtP/nwiA5/NEn0RKhNNp/ObL9sCu4kC4BrA6sexTGSGj5uohDuQmQzc8LGW\nxg5qqo67kom6spZ20a5YJgqAS9pQYJnIDVdZluImMuWhGlIPva5cyLVmAOztS0NwE/mSQRftimWi\nAKiG6ZotsEzkhm2jOqAcN5GNDNRGdUOvKxdykkGXMlGOBWRfa2lXkUGJbbpIMmCZKB364iZyRQal\ndZwukJsMupSJunITdUUGW1syL0tL7f62DcWSQVtuoqEPMDncRDk2qvNxEw29rlwoXSbSbVQX4iZK\nRQY2N5Euf12QwalTslxiNgTMhSLJYGUFOH16/zN762giE3VhKesCKd1EuXZa9F1AHnpdueBjLe3a\nTVTPX0hkkMpaaltA1uWv7Xa1sACcPFne5KZIMlhdlcy5uGhnziYy0fa2TN9nc7s+Y3lZhqSmB9iE\nuIlUh03RaX3zwDLRHEN1E3W5UV1XMhGTgSeqZGBDE5loLIML0TzSauomylVmvGbgh9JlItNg26ab\nqC9koGSiklAkGays+JFBE5loTLKDjVxD3ES5yszHTTQGSc+FPrqJXJFGLmupr5uoK2vpqVPlTW6K\nJIPVVRlG+ZCBkolCyKBpONw32MozxE2Uq8w4MvDDEN1ESqZ1PYfbF32JDFgm8oQavFzadExoOzaZ\nCJDXbCpPZXPrUiZaWHCvaezslGXD6wKly0Q6t45Perb6D0VfrKUnT5YX6RZJBiEyUeggxTLRXqgO\n4+MmyikTmfKwsFCmDa8L9NFN5BNp2Oo/FKEb1XUhE6k2XdpktEgyCJGJQkNblon2Qn3WtUxkykOp\nIXUXGKKbSJ1HlMbZxzJRPIolg9DIIPSxl2OTiWwLyNX/OuQuMxcZlDiL6gJ9XED2JYMUEhHQHzJg\nN5EnfGWiptbS0iojF1xuoup/HXKXmQ8ZjKWubCh9zSDWrZOSDNhNFI8iySCnTLS0JBvK6dPlVUYu\nNJWJFhfl3ce5GjDLRH4YoptInTe2yKDENt17MgidzRDJ806cKK8ycsHlJqr+1yF3mTEZ+IFlIjfY\nTRSPIslAyUQh1tKQCl1ZkQNbaZWRC03dREDeMrPloeomGjtyuolSWUtj3Doptzix7dLLbiI7iiSD\nnDKROm9MkUFTmUilwZFBtxiymyhlZHD6tHQm1d1JpUUGpbXpYskgl5tInXf8eHmVkQtN3URA3jJj\nN5EfWCZyw2WWKIUMSox2iySDnG4idR7LRBK+ZJCzzNhN5AcbGQghI4MuZaJS3EQhZMBuojmKJAOW\nidKCZaJhwEYGighi79Iekkxka+ulRAYltuliyQBgmSgVVNnEuomAbmUi9ftjh40Mmu76OSSZCDC3\n9VLIACivTRdJBrbBq35crEx0/Ph4pAcbuaoy9pGJcpWZy02kfn/s0G0Ep9CUDNQzL7a25AORUuWv\nbTeRyruuLCYT+fREIcLylxoqb6W16SLJICQyCH2egTpvbDIRYJ95uzpjzjKbTKS8wZGBHYuLZmtp\nk/UCQJbvCy802xBQl7+2I4PJRBKCLj2i/fbSLiIDVU+ltenek0HoYy/VeUwGez/rcs1A/T6TgR25\nZaKm9VuCTATI3zOlV88jy0RzFEkGamD3kS5OnvQ7tn7emGQiW3mGuIlylpmLDMZSVzbkJIMU9VvP\n3+6ufNa4S3ZKTQYrK2FkwDKRRJFkEBoZhDJs7Hl9RarIIGeZcWTgRhsLyCkjAxWxu2SnLiODLray\nL7VN95oMlpbm++bEpF9aZeRCKjKo/k8NJgM3cpNB9X8MYiUYlonKQMIqSAdfNxGRPDY03FLHlxam\n5YKtPEPcRNX/qWFylLCbaI7cbqLq/xjU8+crwaR0EwH234zNY0qwTBSAhQX/2cLqKkcGLqRyE1X/\npwZHBm7kdBOpgalpZFDNn68E03ZkEJPHlGA3USBsFVo/jsnADiaDYSCnTKTKn2Wi/Ci1TRdLBjZH\nQP04lonscLmJdDs8mtJgN1F3yEkGQFxfqiLWqdOVm2hnR75eWkr32z4otU0XSwYcGaSDKzLwLefq\n/9TgyMCN3GQQ05eqiHXqdBUZqPzF3mQXi1LbNJPBCMBkMAz0jQxKl4m6speX2qZ7TwYsE7nh2qjO\nt5yr/1ODZSI3SpeJlNS4uyv/dykTmdbA6mTQRbsqtU0XSwa2Cq2CIwM3XBvV+ZZz9X9quKylY6kr\nG2yPvWzqJgKaRwbA3jz6ykSpraW2iWRM/lKjVLt0sWTAMlE6sEw0DJQuEwFxMswYZaLlZbdpo20U\nlp05QsgglGHHRgYuNxGTQT/AZOCHPpBBaVEB0JAMiOidRPQNItohoissx11LRI8T0ZNEdJtP2iHW\n0tAKXVmRrJyyAZaMFGSg9pjJVWa8ZuBG6WsGwH63TsnW0i6eZaDyUOLkpmlk8HUA/xjA/zEdQEQT\nAHcDeBuAywDcRESvcyWcWyYqsTLqWF9fT5LOwoL0UjeNDHLa8OxksN6L+sqNxUXg9Ol17XdjjAxM\n/aMPkUGJ7bkRGQghnhBCPAXANkRcCeApIcS3hBDbAD4C4AZX2kwG6cgAMJdnKBnkApOBG4uLwMbG\nuvY7JoM5mAzi0MaawasBPFt5/+3ZZ1b4uoliraVjkx1M5enr5MhdZrxRnRsLC3PbZh3TaXNHToo6\nrm4E1+VGdab0YvKXGgsLZbZnJx8T0acAHKp+BEAA+E9CiAdzZezAAb9nsR44IP9C0w49p+8wlefK\nSr5yDoEpH4uL891px47lZfmM4p/5mf3fHT0KXHpps/RT1PHyMnD4sEzniSeA97zHfc7KinwITirY\nxo7lZeDIEeA3fxN47jngkkvS/a4vVlbKHH9IVJ8OHZsI0f8G8B+EEF/RfHcVgCNCiGtn728HIIQQ\nv2pIq3mGGAwGY2QQQjRa0UvpDTFl5GEAlxDRRQC+A+DdAG4yJdL0ghgMBoMRjqbW0huJ6FkAVwH4\nGBH98ezzVxLRxwBACLED4FYADwH4CwAfEUI81izbDAaDwUiJJDIRg8FgMPqNYu5AjrkxbSggovOJ\n6LNE9BdE9HUi+rezz19KRA8R0RNE9EkiOth1XtsCEU2I6CtE9MDs/SjLgogOEtHvE9Fjs/bxD0Zc\nFv9udpPrI0T034loeSxlQUT3EtExInqk8pnx2onoDiJ6atZufsrnN4ogg9gb0waEKYB/L4S4DMAb\nAPzr2fXfDuDTQohLAXwWwB0d5rFtvA/Ao5X3Yy2LXwPwcSHEjwL4CQCPY4RlQUSvAvBvAFwhhPj7\nkOudN2E8ZfFByPGxCu21E9GPAXgXgB8F8HYAv0Hkvl20CDJA5I1pQ4EQ4rtCiK/NXp8E8BiA8yHL\n4L7ZYfcBuLGbHLYLIjofwHUA/mvl49GVBRGdB+AfCSE+CABCiKkQ4gRGWBYzLAA4m4gWAZwF4ChG\nUhZCiM8D+Nvax6Zrvx5ybXYqhHgGwFOQY6wVpZBB1I1pQwQR/T0AlwP4AoBDQohjgCQMAK/oLmet\n4r8A+I+Q97MojLEsfhjA94nogzPJ7B4iOoARloUQ4jkA/xnAX0GSwAkhxKcxwrKo4BWGa6+Pp0fh\nMZ6WQgYMAER0DoA/APC+WYRQX90f/Go/Ef00gGOzSMkW2g6+LCClkCsAfEAIcQWAU5DSwBjbxUsg\nZ8IXAXgVZITwzzDCsrCg0bWXQgZHAVxYeX/+7LPRYBb6/gGADwkhPjr7+BgRHZp9/0MA/rqr/LWI\nNwK4noieBvBhAG8hog8B+O4Iy+LbAJ4VQnxp9v5/QpLDGNvF1QCeFkI8P7Or/yGAf4hxloWC6dqP\nArigcpzXeFoKGbx4YxoRLUPemPZAx3lqG/8NwKNCiF+rfPYAgMOz1z8H4KP1k4YGIcQvCCEuFEJc\nDNkOPiuEuBnAgxhfWRwD8CwR/cjso7dC3qszunYBKQ9dRUSrs8XQt0IaDMZUFoS90bLp2h8A8O6Z\n2+qHAVwC4P86Ey/lPgMiuhbSOTEBcK8Q4v0dZ6k1ENEbAXwOcktwMfv7BcgK/B+QLP8tAO8SQhzv\nKp9tg4jeDLnNyfVE9DKMsCyI6CcgF9KXADwN4BbIhdQxlsWdkBOEbQBfBfAvAJyLEZQFEf0ugDUA\nPwDgGIA7AfwRgN+H5tqJ6A4A/xyyrN4nhHjI+RulkAGDwWAwukMpMhGDwWAwOgSTAYPBYDCYDBgM\nBoPBZMBgMBgMMBkwGAwGA0wGDAaDwQCTAYPBYDDAZMBgMBgMAP8fe62ml2nF+r0AAAAASUVORK5C\nYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xor_set = [((0,0),0), ((0,1),1), ((1,0),1), ((1,1),0)]\n", + "plot_xys(xor_set)\n", + "\n", + "(errs,_) = perceptron(xor_set,100)\n", + "plt.figure()\n", + "plt.plot(errs)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Validation error: 0.02\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEACAYAAACj0I2EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAHlRJREFUeJzt3X+MW9d1J/DvoeXdyI1kcYrahSX2NXKQOtAgCll0M2pm\nG6apEEluEqcotm2MOk0l+4/WLjFe7MYJoLU0wKJddDsEF/IfnkoO4kppFzYKNEUsWXaSGbFbqXE6\nM0k6dt3WA9C0nKgJH22rcIwm5tk/hvOLw5khH9979973vh+A0AzF4bvDeTzv8txz7xVVBRERuS9j\nugFERBQOBnQiooRgQCciSggGdCKihGBAJyJKCAZ0IqKE2DKgi8gZEbkmIt9edV9WRC6KyIsi8rSI\n3BxtM4mIaCu99NC/AOCjHfc9BOBZVf05AF8D8LmwG0ZERP2RXiYWiYgH4K9V9X3t7/8RwIdU9ZqI\n/DSAKVW9I9qmEhHRZoLm0G9R1WsAoKrfA3BLeE0iIqIgwhoU5foBRESGbQv4c9dE5NZVKZd/3eiB\nIsJgT0QUgKpKP4/vtYcu7duSLwP4nfbXnwbwV1s0ijdVPPzww8bbYMuNrwVfC74W62+NRgOXLl2C\n7/v9xPFlvZQtfgnA3wJ4j4i8LCKfAfBHAA6KyIsAPtL+noiIAjpXLuORQgFvFYs4lc8Heo4tUy6q\n+qkN/utXAh2RiIjW8H0fC5UKjtdqAICDtRr+R4Dn4UzRGBWLRdNNsAZfixV8LVak9bWYn5/HSL0+\n8PP0VIc+0AFENOpjhMH3fczPz2N4eBjZbNZ0c9axvX1ErjP5Hms2mziVzy/30IHFQUuNaFA00cqT\nZRSOFVA8XUT+aB7lyXLXx/m+j2q1imazaWX7iCiYzvz1uXK877FsNou9pRLGPQ/PZDIY97xAz5P6\nHrrv+ygcK6C2f+XK6M15mDkzg6GhoeX7ypNlVC5UUN9RR+56DqVDJYzdN2ZN+4goGN/38UihsKZ3\nPO55uH8m/veY7/t4/vnnsW/fPgwNDbGH3q/5+XnUd6zNXdV31vH8888vf+/7PioXKqjtr6G1t4Xa\n/hoq5yuBS4vCbh+RC0x8wu3lmN3y1wfqZt5jQ0NDGB0dDZzySX1AHx4eRu56bs19uTdy2Ldv3/L3\nJoNqL+0jsp2JlEavxxweHsaV3Nr32OWcm++x1Af0bDaL0qESvDkPmYUMvDkPpcOlNVdIk0G1l/YR\n2Wx1Sd7BVgvHazW8VIn2E24/x+yWv7695OZ7LPU59CWrc1fd/pDlyTIq5yuo76wj90YOpcPx5NB7\nbR9Rr+Ku5qhWq3irWMTBVmv5vmcyGWyfnsbo6Ggk7QxyTNveYyLSdw498qmsi4dIhkajodVqVX3f\nN90UokDOTkzouOfpxUxGxz1Pz05MRH5M3/d13PNUgeXbSc/b9H00aDuDHNM27djZX7zt9wf6PkCC\nAjqRyxqNRtcg12g0Ij/22YkJPdkO0Ce3CNBhtbOfY9ooSEBnyoV6wolN7gua+ghLrymNMNtpWxql\nH0FSLqkfFKWtcWJTMpiu5ui1JC/Mdg5aBugaBnTalMkafAqXK9UcrrTTRky50Kaq1SqKp4to7V35\n+JtZyGD63ng+ptOiMFNerqQhXGlnVJhyodBxYtMiU+v4AOFPynElDeFKO23CgE6b4sQmsws3mZiU\nQ+5iyoV6ktaPv6YXbjJdmULmMOVCkUnrx1/TCzeZrkwhtzCgE20izIAaJA/Pig/qB1MuRFs4Vy7j\npUoFB+p1XM7lcHuphLvH+lvH51y5jIVKBSP1Oq7kctjb53OkNeWVZkFSLqkO6Jz9SL0aJKCazsOT\nm5hD74Otsx9NlsfRxgYZQzCdh6f0SGVAt3X2o60XGRoMBzYpLqkM6DZu62brRYYGtzSw+dCePZgQ\nwef27OHAJkUilQHdxtmPNl5kKFzvEME+EfxH6W/PAqJepTKg2zj7MehFhjl3+y3N9jxRr+OjrRZO\n1Ouc7UmRSH2Vi02lYP1uc1eeLKNyoYL6jjpy13MoHYp3WzzqDWd7UhAsW0yAXi8yvu+jcKyA2v6V\nUjhvzsPMGZbC2abZbOJUPr+ubPGB2VkrOhJJ52p5MssWE6DX8jjm3N3B2Z7mmFxYzQT20B3VbDaR\nP5pf10OffYy9PlvZluJLOtcndLGHHjOTA5I2DuzS5tK6wJkpYU3ocqnwgD30gGwZkGSvj6i7MMYu\nBl2DZxAcFI0JBySJ3DDIwmqmUzYM6DHhPptE7gj6KdZ0uSlz6DGxcaYpEXUXdOzCxTV4GNAD4IAk\nUfK5WG46UMpFRMYAHAXQAvAdAJ9R1X/veEziUi5LOCBJlHym3uex5tBF5DYAfwPgDlX9dxH5vwC+\noqqPdzwusQGdiCgqQQL6tgGPeQOAnxCRFoCbALw64PMREVFAgXPoqvoqgD8B8DKAqwBeU9Vnw2oY\nEdEgXJoQFJbAPXQR2QXgEwA8AK8DeFJEPqWqX+p87IkTJ5a/LhaLKBaLQQ9LRLSl1ROCTsU8ISio\nqakpTE1NDfQcg+TQfx3AR1X13vb3vw3gA6p6f8fjmENPKVdXuSO3mZ4QFJa469BfBjAiIu8QEQHw\nEQAvDPB8lCDcH5VMSfOm3IPk0L8B4EkAswC+BUAATIbUrp6kMUfmAu6PSia5OCEoLANNLFLVk6r6\nXlV9n6p+WlV/FFbDtsIeoL24VjuZ5OKEoLA4uZYLF8eyG9dqJxv4vo8rV64AAA4cOODcuZeatVzY\nA7Qbl0YgG5z/4hfx97/3e7jxYx9LxW5FgKM9dPYAzemncoVLI5ApSah0SU0PnT1AM/odt+AOPWRK\nWitdnOyhL2EPMD4ctyCXhLFbkWmp6aEvYQ8wPhy3IJektdLFuR46Zx+awXELcpHLn+IT30Nn7bk5\nHLcgF6XtU7wzPXTmcO3gco+HyCWJ7qEzh2uHtPV4iFziTEDnxsxERJtzJqAzh0tEtDlncuhLmMMl\nojSIdZPong/ADS6IiPqW6EFRIiLaHAM6EVFCMKBbhDswEdEgGNDbTAdTzoIlokFxUBSLwbRyoYL6\njjpy13MoHSph7L6x2I7PWbBE1ImDogHYsKExZ8ESURhSH9BtCKacBUtEYUh9QLchmHIWLBGFgTl0\ntHPo5yuo76wj90YOpcPx5tCXcBYsES3hTNEBMJj2jpuMEEWPAZ0iZ7oiiKLBi7R9GNApUiyvTKZz\n5TIWKhWM1Ou4ksthb6mEu8d4kTaNZYsUKRsqgihcvu9joVLB8VoNB1stHK/V8FIl3rJdCg8Depvp\nmaIusKEiiMI1Pz+Pkfrai/SBOi/SrrI2oMcZYDntvjcsr0ye4eFhXMmtvUhfzvEi7Sorc+hxDrwx\nL9w/VgQly7lyGS9VKjhQr+NyLofbmUO3QiIGReMOsNVqFcXTRbT2tpbvyyxkMH3vNEZHR0M/HtmD\nlR0reJG2TyIGReMeeGNeOJ3Olct4pFDAW8UiTuXzOFfeOM2WhvGVoaEhjI6OMphHIM7zx7qAHneA\nZV44ffqp7Ogn8JM5tl50Yz9/VDXS2+Ih+jPx6IR6d3mauSej3l2eTjw60fdz9KvRaGi1WlXf9yM/\nFpl16dIlvZjJqALLt4uZjFar1TWPazQaOu55ax530vO00WiYaTh1dXZiQsc9Ty9mMjrueXp2Ivp4\n0YtBz5927Owv3vb7A30fIEBAX3oxGGApCr7vd32jdZ5rvQZ+Msfmi+6g50+QgD5QykVEbhaRJ0Tk\nBRGZF5EPDP6ZYRFzehSVbDaLvaUSxj0Pz2QyGPc83F5an2ZzqaTP1pRD1Gyuozdx/gyaQ68AeEpV\n3wtgP4AXBm8SUfTuHhvD/TMz2D49jQdmZ7uW6fUa+E1Lc57f5ouuifMncNmiiOwEMKuqt2/xOA16\nDCIb2FzS5/s+HikUcLy2UuY77nm4fyY98yhsr6MPev7EWocuIvsBTAJ4Hou9828CKKnqDzsex4BO\nFJFqtYq3ikUcbK3Mo3gmk8H26XTNo7D5ohtU3HXo2wAUADyiqgUAbwJ4aIDnI6I+2ZxyiJONY24m\nxjW2DfCzrwCoq+o3298/CeCz3R544sSJ5a+LxSKKxeIAhyWiJct52o6Ug02BLY1WL0l8qscliaem\npjA1NTXQcQea+i8i0wDuVdV/EpGHAdykqp/teAxTLkQRS2LKwVVhjWvEvpZLO49+GsCNABYAfEZV\nX+94DAM6EaVGWOMasa/loqrfUtVfUNX3q+qvdQZzIlovrTXjaWFyXMO6tVyIwmRb8ExzzbjL+jmP\nTM5fsG75XKKw2LZX5ka51bu/+lW8+uqrXMbXUkHPo0HHNRKxHjpRGGyccNMtt/q0CJ645Rb8xve/\nb8VFh9YyeR4lYj10ojDYuMZHt9zq05kM/vjatdg3aLYtFWUrG8+jzTCgUyLZOOGmM7f6+VtvxTvf\nfhurP4zHESyYx++djefRZqwJ6OwxUJhsXVhr9aJg916+jBs9b83/Rx0s+tncg+w9jzZiRQ49zk2h\nqbuk7q9p+4SbuBeW4tovwZg4j5wcFI17U2hajxdUs+IMFs1mE6fy+XWDfA/Mzlp5wUszJwdF494U\nmtbyfR+VCxXU9tfQ2ttCbX8NlfP8CB6nOBeWMpVCYEo1HsYDetybQtNavKCmTy+be4SJg7DxMR7Q\ns9ksSodK8OY8ZBYy8OY8lA7312NYffVnT6A/vKCmU1yfCjgIGy/jOfQlQfOIq/O/O1/cCdkheP22\n15kL7kN5sozK+QrqO+vIvZFD6TBfNwoHB2GDc3JQdBBrBlTfBPAcgA+t/D8HV3tnezUIuYmDsME5\nOSg6iDX53+8D2LP2/5kL7p2NO76Q+1yr43ad0z30ZrOJ/NH8Yg/9hwC+gXU99NnH2BMgMo2fAPuX\nuh76mgHV72aw681dyFazgQdXiSga/AQYD6d76EtWX/1VlT0BInJe6gZFe7HRlHbf93H58mWICA4c\nOJDo4J/Uaf1ESZa6lMtWypNlFI4VUDxdRP5oHuXJ8vL97/6Nd+NX/+JXcecf3om9h/cu/1/SbPQa\nEFHyJLaHvtEaMV/931/Fhx/8MOqFVbMjp4A9N+3Bt/7sW4kqceQ6OUTuYg99lY2mtF+4cAFXd11d\n++AccPXtq4krceS0fqJ0SWxA32hK+5EjR7D7td1rH1wHdt+wO3HT3Tmtn3qRluUy0vB7Jjagb7RG\nzLve9S6M3TmGbDUL/AuAZ4FdP9yFBz/xYOIGDMNYJ4eSLS0LZ6Xl90xsDn2J7/u4cuUKAKypZlm6\nX0QwMjKS6CDHSR3UjY0baUfB1d+TZYtdcPMGou7SsnCWq78nB0U7cPMGoo25tgFyUGn5PYGEB3RW\neRBtLC0LZ6Xl9wQSnnJZs3hXGxfsIlorLWMsrv2ezKF3wc0b3MElCohWMKBvwLUrcxqdK5exUKlg\npF7HlVwOe0ulyPe6JLIZAzo5ydWyMqIoscqFnDQ/P4+R+trB6wN1Dl5TcGmYFdoNAzoZl6ayMope\nWmaFdsOATsYs9aIApKasjKLl+z4WKhUcr9VwsNXC8VoNL1XSM/eEAZ2M6OxFAcD9MzPYPj2NB2Zn\nOSBKgaQ9fceATrHbqBcFgPtO0kDSnr4bOKCLSEZEZkTky2E0iJIv7b0oik6aZoV2M3DZooiMAfh5\nADtV9eNd/p9li7RGs9nEqXx+XZniA7OcwUvhSMLck9jLFkVkD4AjAE4P8jyUXN3Kx9Lei3KRa2WA\nQ0NDqUzfDdRDF5EnAPxPADcD+K/sodNqW83+TEIvKg04i9eMWGeKisidAA6r6v0iUsRiQP9Yl8cx\noKcQZ38mA/+O5gQJ6NsGON4HAXxcRI4A2A5gh4g8rqr3dD7wxIkTy18Xi0UUi8UBDksu2Gzg0+ZN\nBWgt/h3jMzU1hampqYGeI5S1XETkQ+gz5bJ6ZT1V5Sp7CcOBz2Tg39GcuHvoga3eFm7nizshOwSv\n3/Y6t4hLkOWBz0oFB+p1XM7lOPDpIP4d3RL7aou+76NwrLC46cSbAJ4D8KGVx3tzHmbOMD+XFBz4\nTAb+HePnxPK51WoVxdNFtPa2gBqAHwO4feXxmYUMpu+1e/NWIqKoObF87vDwMHLX21NzbwHwytr/\nz72Rnmm6RJQ8Jmv2Yw/o2WwWpUMleHMeMt/NYNebu5CtZpFZyMCb81A6zPwcEbnJ9NK9xnYsWp2T\nU1Xm54jIaf3W7G+1h64TOXQioiSqVqt4q1jEwVZr+b5nMhlsn14/JtjL7Fsncuguc209CyKKT69L\n90a5CQcDeo/Kk2UUjhVQPF1E/mge5cn0bGtF8WGnwV29LjoX5fLRTLn0YE3tfBvr5SlsXAQruK3y\n0XG3ZbMxwV5n3zLlEpH5+XnUd6y9otZ3ckMGCk/a98IchOnKkk5bLd0b5fLR7KH3oNlsIn80v66H\nPvsY17OgcPQzoOaysHvSLq8GuVVPnj30iKypnWe9PEUgDXthRtGTdnk7wyg24WAPvQ9cz4KidK5c\nxksdi2AlJYceVU86yatBsg6dyLBBUwpJ7TREmVIycSGMYxCWAZ0ooDDeoKxS2VjUPekwLoS9ngNx\n/Z2DBHSoaqS3xUOEp9Fo6KVLl9T3/VCfl9Lr7MSEjnueXsxkdNzz9OzERN/P0Wg0dNzzVIHl20nP\n00ajEX6DHXV2YkJPtl/nkwFf56j0eg7E+Xdux87+4m2/P9D3AUIM6BOPTqj3SU8z92TU+6SnE4/a\nc0KQm8J6g166dEkvZjJrnudiJqPVajWahjuq0WhotVq1qkPWzzkQ5985SEB3psrF931ULlRQ219D\na28Ltf01VM6zTpcGE1aVRBqqVMIQRWXHoPo5B2z/OzsT0Dm5h6IQ1hs0yskiFK1+zgHb/87ODIpy\ncg9FJcwqiaRWqSRdv+dAHH/nxFe5lCfLqJyvoL6zjtwbOZQOc0NpCgcDMdl2DiQ+oAP2vehERFFI\nRUAnIkoDruVCRJRiDOhEFAg347APAzoR9c22NchpEXPoRNQXl9cgdwlz6EQUOZfXIE86BnQi6ovt\n09/TzMqAzsEWInvZPv09zazLoZcny6hcqKC+o47c9RxKhzgblOJl0w7yNuMkv2g5P7HI930UjhXW\nrdcyc4aDLRQPblJBtnB+UJQrKpJJvu9joVLB8VoNB1stHK/V8FKFSzSTO6wK6MPDw8hdXzvYknuD\ngy0UD1ZvkOusCujZbBalQyV4cx4yCxl4cx5KhznYQvFg9Qa5zqoc+hIOtpApJnaQJ+rG+UFRIhuw\nQ0E2iDWgi8geAI8DuBVAC8Cfqur/6fI4owGdJWhE5KK4q1x+DOBBVd0H4ACA3xeROwZ4vtCVJ8so\nHCugeLqI/NE8ypNcQIiI+ufKZMfAAV1Vv6eqc+2v/w3ACwB2h9WwQfm+j8qFCmr7a2jtbaG2v4bK\neZagEVF/XFpZMpQqFxH5WQDvB/B3YTxfGFjTni6u9KDILa7NTdg26BOIyDsBPAmg1O6pr3PixInl\nr4vFIorF4qCH3dJSTXsNK7NOWdPeH1fGH1bP7jzF2Z0Uos3mJoyOjoZ6rKmpKUxNTQ32JKoa+IbF\nC8IFLAbzjR6jpkw8OqHeXZ5m7smod5enE49OGGuLa85OTOi45+nFTEbHPU/PTtj52jUaDR33PFVg\n+XbS87TRaJhuGiWA7/tdzy/f9yM/djt29hWTBypbFJHHAfxAVR/c5DE6yDEGxRK0/rm0gUG1WsVb\nxSIOtlrL9z2TyWD79HToPShKJ1NzE+IuW/wggEsAvgNA27fPq+qFjscZDejUP5eCZLPZxKl8ft3F\n54HZWV7AKTQmOoaxli2q6v9T1RtU9f2qmlfVQmcwTyObB+d838dXvvIVPPXUU5u2z6Up8Fybm+Iw\nNDSE0dFR688rzhQNkc1Lr54rl/H0+Dj2vPYafgnA17NZvO/48Q3b59oUeKbWKGkSN/XflSoLwO68\ns+/7+OP9+3HTK6/g+Kr7H87lUJqb27B9DJJE5ji/Hvpqrs3ytHnp1fn5efzU1asY6bj/F69e3bR9\nrnzMJKJFVgZ0F2d52px3Hh4exg9278aVjvv/dvduK9oXF5vHN2hj/Lv1zsqA7uIsT5sH57LZLPY9\n+CD+edcufA6LEwf+ezaL94yNWdG+OPQyfZuBwz4uTbu3gZU59GazifzR/Lq9RWcfs78Uzea8s+/7\nuHLlCkQEIyMj1rUvKr2Mb9g8oJ1WNo9LxSExOXSXdy6yOe88NDSEI0eO4PDhw1a2LypbjW+4tl5H\nWtg8LmUrKwM6AIzdN4aZMzOYvncas4/NYuw+9pYomK3GNxg47GTzuJStrA3ogN29XXLHVuMbDBx2\nsnlcylZW5tCJorDZ+IZrE6nSxOZxqSg5PbHIpUlElExpDRxkJ2cDenmyjMqFCuo76shdz6F0qMSc\nORGlmpMB3fd9FI4V1pUozpxJR2kSEVE3TpYtujiJiIjIRsYD+tJWcatxqzgiov4ZD+guTyIiIrKJ\n8Rz6ElYYEBGtcHJQlIiI1nNyUJSIiMLBgL4BLqVKRK5hQO+CazATkYuYQ++Q9jWYiWyS5iVBmEMP\nQb9LqTI1QxQNflLuHwN6h36WUuUJRxQNbjoSDAN6h17XYOYJRxQdbjoSDHPoG9hqolO1WsVbxSIO\ntlrL9z2TyWD79DRGR0fjbCpR4jSbTZzK59eNZT0wa/++wmFhDj1EW+2WlORdblwZF3ClndQ/7lYU\nDHvoA0jiLjfnymUsVCoYqddxJZfDXkt/J9vbmebqjDCleUkQTv03wIYTLqzg4UrJpu3ttP1iQ25g\nysUA0xtZh1lp48pAlM3t5GA5mcSA7rCwg0eU4wJh5rttHr+w+WJDyceA7rCwg0dUA1Fh1+vbPGBm\n88WGks+JHDoHmLqLqrQrzHGBKPPdNoxfdJPEwXKKXyIHRcuTZVQuVFDfUUfueg6lQyWM3cc3xxLb\ng0da6/VtvdiQOxIX0H3fR+FYAbX9K707b87DzJnee3dp6N0vBY/bbrsNV69etep35QQRomBir3IR\nkUMi8o8i8k8i8tlBnqub+fl51HeszRHXd/aeI07LWitDQ0OoPfcczv3yL1v3u9qc7yZKHFUNdMPi\nxeBfAHgAbgQwB+COLo/ToHzfV++TnuIElm/eXZ76vr/lzzYaDR33PFVg+XbS87TRaARuz6C+/vWv\nR/K8Nv6unRqNhlar1eW/XVSvhYv4Wqzga7GiHTv7isuD9ND/E4B/VtWaqv4IwF8A+MQgF5dO2WwW\npUMleHMeMgsZeHMeSod7693ZWD42NTUVyfPa+Lt26qzXj+q1cBFfixUbvRZc5qE3gwT03QBWR5FX\n2veFauy+McycmcH0vdOYfWy25wHRNJWPpel3pfRJS+o0DE7UoQeZjZmm3G2afldKF8687U/gKhcR\nGQFwQlUPtb9/CIs5n//V8bjkLuRCRBQhjatsUURuAPAigI8A+C6AbwD4LVV9IdATEhHRQLYF/UFV\nfVtE7gdwEYupmzMM5kRE5kQ+sYiIiOIR2aBo1JOOXCEie0TkayIyLyLfEZE/MN0m00QkIyIzIvJl\n020xSURuFpEnROSF9vnxAdNtMkVExkTkH0Tk2yJyTkT+g+k2xUlEzojINRH59qr7siJyUUReFJGn\nReTmrZ4nkoAuIhkApwB8FMA+AL8lIndEcSwH/BjAg6q6D8ABAL+f4tdiSQmAPUXy5lQAPKWq7wWw\nH0AqU5YichuABwAUVPV9WEwF/6bZVsXuC1iMl6s9BOBZVf05AF8D8LmtniSqHnrkk45coarfU9W5\n9tf/hsU3bej1+q4QkT0AjgA4bbotJonITgD/WVW/AACq+mNVfcNws0y6AcBPiMg2ADcBeNVwe2Kl\nqn8DoHPW1CcAfLH99RcB3LXV80QV0GOZdOQaEflZAO8H8HdmW2JUGcB/A5D2wZt3AfiBiHyhnX6a\nFJHtphtlgqq+CuBPALwM4CqA11T1WbOtssItqnoNWOwYArhlqx9wYmJREojIOwE8CaDU7qmnjojc\nCeBa+xOLtG9ptQ1AAcAjqloA8CYWP2KnjojswmJv1ANwG4B3isinzLbKSlt2gqIK6FcB/Myq7/e0\n70ul9sfIJwH8mar+len2GPRBAB8XkQUAfw7gwyLyuOE2mfIKgLqqfrP9/ZNYDPBp9CsAFlTVV9W3\nAfwlgF803CYbXBORWwFARH4awL9u9QNRBfTnALxbRLz2aPVvAkhzRcNjAJ5X1Yrphpikqp9X1Z9R\n1b1YPCe+pqr3mG6XCe2P0nUReU/7ro8gvQPFLwMYEZF3iIhg8bVI4wBx56fWLwP4nfbXnwawZWcw\n8MSizXDS0QoR+SCAuwF8R0Rmsfix6fOqesFsy8gCfwDgnIjcCGABwGcMt8cIVf2GiDwJYBbAj9r/\nTpptVbxE5EsAigB+UkReBvAwgD8C8ISI/C6AGoD/suXzcGIREVEycFCUiCghGNCJiBKCAZ2IKCEY\n0ImIEoIBnYgoIRjQiYgSggGdiCghGNCJiBLi/wOo+II5U8eXxQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAEACAYAAAC3adEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nPgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "noise_chance = 0.0\n", + "N = 100\n", + "xys = [(uniform(0,10),uniform(0,10)) for _r in range(0,N)]\n", + "secret_f = lambda x: x*2 - 1\n", + "dataset = [(xy,(1 if (secret_f(xy[0]) <= xy[1] or uniform(0,1)= 0 else 0\n", + " error = actual - predicted \n", + " val_net_error += abs(error)\n", + "val_error = val_net_error/len(validation)\n", + "print(\"Validation error:\",val_error)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [Root]", + "language": "python", + "name": "Python [Root]" + }, + "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.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From 17006c7b7e390bbbc98e5f228f8bc8a9174082f3 Mon Sep 17 00:00:00 2001 From: erelsaul Date: Wed, 20 Jul 2016 23:12:45 +0300 Subject: [PATCH 3/4] Revert "Perceptrons_Erel_SAUL" This reverts commit dcd125c1499bdcfe036c3745aa9eed624105b9eb. --- projects/6-perceptron/Perceptrons.ipynb | 175 ++++++++++ .../6-perceptron/Perceptrons_Erel_Saul.ipynb | 306 ------------------ 2 files changed, 175 insertions(+), 306 deletions(-) create mode 100644 projects/6-perceptron/Perceptrons.ipynb delete mode 100644 projects/6-perceptron/Perceptrons_Erel_Saul.ipynb diff --git a/projects/6-perceptron/Perceptrons.ipynb b/projects/6-perceptron/Perceptrons.ipynb new file mode 100644 index 0000000..c2e9823 --- /dev/null +++ b/projects/6-perceptron/Perceptrons.ipynb @@ -0,0 +1,175 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "from random import uniform, choice\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def plot_xys(xy_l_tuples,sz=15):\n", + " t_yes = [a[0] for a in xy_l_tuples if a[1] == 1]\n", + " t_no = [a[0] for a in xy_l_tuples if a[1] == 0]\n", + " plt.plot([x for (x,y) in t_yes],[y for (x,y) in t_yes],'go',markersize=sz)\n", + " plt.plot([x for (x,y) in t_no],[y for (x,y) in t_no],'ro',markersize=sz)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def tuple_append(tpl,elt):\n", + " return tuple(list(tpl)+[elt])\n", + "\n", + "def perceptron(training, epochs):\n", + " # some parameters, maybe interesting to make these arguments\n", + " rate = 1.0\n", + " # how many weights do we need?\n", + " feature_count = len(training[0][0])\n", + " # pad each training example with a dummy 1 input\n", + " training = [(tuple_append(ins,1), label) for (ins,label) in training]\n", + " # initialize weights to random values\n", + " weights = [uniform(0,0.05) for _r in range(0,feature_count+1)]\n", + " # let's store the errors found during training\n", + " errors = []\n", + " for i in range(0,epochs):\n", + " # in each epoch, pick a subset of the training set (just one for now)\n", + " (example,actual) = choice(training)\n", + " # calculate the perceptron activation and the predicted category\n", + " # Note: You can use dot(vec1, vec2) to get the dot product between two sequential collections.\n", + " # calculate the error between predicted and actual and add it to errors\n", + " # update each weight according to the perceptron update rule\n", + " return (errors,weights)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "and_set = [((0,0),0), ((0,1),0), ((1,0),0), ((1,1),1)]\n", + "plot_xys(and_set)\n", + "\n", + "(errs,_) = perceptron(and_set,100)\n", + "plt.figure()\n", + "plt.plot(errs)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "or_set = [((0,0),0), ((0,1),1), ((1,0),1), ((1,1),1)]\n", + "plot_xys(or_set)\n", + "\n", + "(errs,_) = perceptron(or_set,100)\n", + "plt.figure()\n", + "plt.plot(errs)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "xor_set = [((0,0),0), ((0,1),1), ((1,0),1), ((1,1),0)]\n", + "plot_xys(xor_set)\n", + "\n", + "(errs,_) = perceptron(xor_set,100)\n", + "plt.figure()\n", + "plt.plot(errs)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "noise_chance = 0.0\n", + "N = 100\n", + "xys = [(uniform(0,10),uniform(0,10)) for _r in range(0,N)]\n", + "secret_f = lambda x: x*2 - 1\n", + "dataset = [(xy,(1 if (secret_f(xy[0]) <= xy[1] or uniform(0,1)= 0 else 0\n", - " error = actual - predicted \n", - " for i in range(0, len(weights)):\n", - " weights[i] += example[i] * error\n", - " errors.append(error)\n", - " # Note: You can use dot(vec1, vec2) to get the dot product between two sequential collections.\n", - " # calculate the error between predicted and actual and add it to errors\n", - " # update each weight according to the perceptron update rule\n", - " return (errors,weights)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAEACAYAAABWLgY0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAEACAYAAABRQBpkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "and_set = [((0,0),0), ((0,1),0), ((1,0),0), ((1,1),1)]\n", - "plot_xys(and_set)\n", - "\n", - "(errs,_) = perceptron(and_set,100)\n", - "plt.figure()\n", - "plt.plot(errs)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAEACAYAAABWLgY0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nXpIaZuQlqWH/B+0+jLk322bvAAAAAElFTkSuQmCC\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAEACAYAAABRQBpkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n5OM4zVYAAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "or_set = [((0,0),0), ((0,1),1), ((1,0),1), ((1,1),1)]\n", - "plot_xys(or_set)\n", - "\n", - "(errs,_) = perceptron(or_set,100)\n", - "plt.figure()\n", - "plt.plot(errs)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAEACAYAAABWLgY0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAEACAYAAABRQBpkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "xor_set = [((0,0),0), ((0,1),1), ((1,0),1), ((1,1),0)]\n", - "plot_xys(xor_set)\n", - "\n", - "(errs,_) = perceptron(xor_set,100)\n", - "plt.figure()\n", - "plt.plot(errs)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Validation error: 0.02\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEACAYAAACj0I2EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAEACAYAAAC3adEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nPgAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "noise_chance = 0.0\n", - "N = 100\n", - "xys = [(uniform(0,10),uniform(0,10)) for _r in range(0,N)]\n", - "secret_f = lambda x: x*2 - 1\n", - "dataset = [(xy,(1 if (secret_f(xy[0]) <= xy[1] or uniform(0,1)= 0 else 0\n", - " error = actual - predicted \n", - " val_net_error += abs(error)\n", - "val_error = val_net_error/len(validation)\n", - "print(\"Validation error:\",val_error)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [] - } - ], - "metadata": { - "anaconda-cloud": {}, - "kernelspec": { - "display_name": "Python [Root]", - "language": "python", - "name": "Python [Root]" - }, - "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.5.2" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} From 3caa8a5ef2815848f10842d9f50bc4dfa5ab70aa Mon Sep 17 00:00:00 2001 From: erelsaul Date: Wed, 20 Jul 2016 23:18:55 +0300 Subject: [PATCH 4/4] PERCEPTRONS EREL SAUL ASSIGNMENT --- .../6-perceptron/Perceptrons_Erel_Saul.ipynb | 306 ++++++++++++++++++ 1 file changed, 306 insertions(+) create mode 100644 projects/6-perceptron/Perceptrons_Erel_Saul.ipynb diff --git a/projects/6-perceptron/Perceptrons_Erel_Saul.ipynb b/projects/6-perceptron/Perceptrons_Erel_Saul.ipynb new file mode 100644 index 0000000..3c110a6 --- /dev/null +++ b/projects/6-perceptron/Perceptrons_Erel_Saul.ipynb @@ -0,0 +1,306 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "from random import uniform, choice\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def plot_xys(xy_l_tuples,sz=15):\n", + " t_yes = [a[0] for a in xy_l_tuples if a[1] == 1]\n", + " t_no = [a[0] for a in xy_l_tuples if a[1] == 0]\n", + " plt.plot([x for (x,y) in t_yes],[y for (x,y) in t_yes],'go',markersize=sz)\n", + " plt.plot([x for (x,y) in t_no],[y for (x,y) in t_no],'ro',markersize=sz)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def tuple_append(tpl,elt):\n", + " return tuple(list(tpl)+[elt])\n", + "\n", + "def perceptron(training, epochs):\n", + " # some parameters, maybe interesting to make these arguments\n", + " rate = 1.0\n", + " # how many weights do we need?\n", + " feature_count = len(training[0][0])\n", + " # pad each training example with a dummy 1 input\n", + " training = [(tuple_append(ins,1), label) for (ins,label) in training]\n", + " # initialize weights to random values\n", + " weights = [uniform(0,0.05) for _r in range(0,feature_count+1)]\n", + " # let's store the errors found during training\n", + " errors = []\n", + " for i in range(0,epochs):\n", + " # in each epoch, pick a subset of the training set (just one for now)\n", + " (example,actual) = choice(training)\n", + " # calculate the perceptron activation and the predicted category\n", + " activation = np.dot(weights, example) \n", + " predicted = 1 if activation >= 0 else 0\n", + " error = actual - predicted \n", + " for i in range(0, len(weights)):\n", + " weights[i] += example[i] * error\n", + " errors.append(error)\n", + " # Note: You can use dot(vec1, vec2) to get the dot product between two sequential collections.\n", + " # calculate the error between predicted and actual and add it to errors\n", + " # update each weight according to the perceptron update rule\n", + " return (errors,weights)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAEACAYAAABWLgY0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAEACAYAAABRQBpkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "and_set = [((0,0),0), ((0,1),0), ((1,0),0), ((1,1),1)]\n", + "plot_xys(and_set)\n", + "\n", + "(errs,_) = perceptron(and_set,100)\n", + "plt.figure()\n", + "plt.plot(errs)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAEACAYAAABWLgY0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nXpIaZuQlqWH/B+0+jLk322bvAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAEACAYAAABRQBpkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAFYVJREFUeJzt3X+sJWV9x/HP5+7eH/yo/DDsKqzgDxTQpFL+oFBtPBbE\nxRKwibHQpoqxDWlKa1pjEGtk9z/9o2k0apQUCRItFY2yWLVg8NaQqKVVgj9A1lhxWXGpgSWy7K97\n99s/5hx2OJxz7zn3PDN3njPvV3Jy75k7zDNn2Mxnnu/zzBxHhAAA7Taz3jsAAFh/hAEAgDAAABAG\nAAARBgAAEQYAACUKA9s32d5j+4EV1vmY7Z2277d9bop2AQBppOoZ3CzpzcP+aPtSSa+IiFdKukbS\npxK1CwBIIEkYRMS9kp5cYZUrJH22u+73JJ1ge3OKtgEAk6trzOA0SbtK73d3lwEAGoABZACANtbU\nzm5JLym939Jd9jy2eVgSAIwpIjzJf5+yZ+Dua5Adkt4hSbYvkLQ3IvYM21BErPjatCn0wAMrr7PW\n14c+FHr3u6vZ9rivG264Yd33oQkvjgPHgmOx8iuFJD0D25+X1JH0Qtu/lHSDpDlJERE3RsTXbL/F\n9s8k7ZP0rknaW1qSDhyYdK8HO3Cgum0DQFMlCYOI+LMR1rk2RVsSYQAAqWU5gLy0JB08WM22Dx6s\nbtvj6nQ6670LjcBxOIpjcRTHIi2nqjelYjtW26f5eelLX5Iuuyx9+1dfLe3eLd19d/ptA0AVbCsa\nNIBcG8pEAJBWdmEQIR050o4yEQDUJbswWF4uftIzAIB0sguDpaXiJ2EAAOlkGwaUiQAgnWzDgJ4B\nAKRDGPQhDAC0UXZh0BtApkwEAOlkFwZ19AwOHiymsAJAWxAGfXrbpXcAoE2yDYMqy0QzM4QBgHbJ\nNgyq7BmceCKDyADahTDo23aEdNxxhAGAdskuDKqcTXTwoLSwULwoEwFok+zCoMqewYEDR8OAngGA\nNiEMSg4cKL4rYX6eMADQLlmGwfw8ZSIASCnLMKhqgJcyEYC2yjIMjj+eMACAlLILg+XlIgyqKhP1\nxgwoEwFok+zCgDIRAKRHGJQQBgDaKsswoEwEAGllGQYLC8VjI3r3HKRCzwBAW2UZBhs3VnPCJgwA\ntFXWYZC6lMMdyADaKrswWF6WNmyo5oTNHcgA2iq7MKBMBADpZR0GlIkAII1sw4AyEQCkk20YUCYC\ngHSyDgPKRACQRnZhwGwiAEgvuzCgTAQA6WUdBpSJACCNrMOAMhEApJFtGFRx9U6ZCEBbZRsGlIkA\nIJ3swmB5mTIRAKSWXRgsLVU3tZQyEYC2yjIMKBMBQFpZh0FVZaLe115GpN0+ADRVtmFQZZlo40Zp\nZib912oCQFNlGwZVlokkSkUA2iW7MKhjNpHEjCIA7ZIkDGxvtf2Q7YdtXzfg72+wvdf297uvD661\nrapmEx05Ih0+LM3NFe+ZUQSgTTZOugHbM5I+LukiSb+SdJ/tOyLiob5Vvx0Rl0/aXnnMIOWV+8GD\nxTbt4j1hAKBNUvQMzpe0MyIeiYjDkm6TdMWA9ZygrcpmE/XCoCd12ABAk6UIg9Mk7Sq9f7S7rN+F\ntu+3/e+2X73WxqqaTdSbSdRDzwBAm0xcJhrR/0g6PSKesX2ppK9IetWwlbdt2/bs751OR51O59n3\nVc0mIgwA5GJxcVGLi4tJt5kiDHZLOr30fkt32bMi4unS71+3/UnbJ0fEE4M2WA6DflXNJqJMBCAX\n/RfJ27dvn3ibKcpE90k60/YZtuckXSlpR3kF25tLv58vycOCYDW92USpw4CeAYA2m7hnEBHLtq+V\ndJeKcLkpIh60fU3x57hR0tts/7Wkw5L2S/rTtbZX1WwiwgBAmyUZM4iIb0g6q2/Zp0u/f0LSJ1K0\nVdVsovLdxxJ3IANol+zuQK5yaml/z4AxAwBtkW0YUCYCgHSyDYO5ueLxEUeOpNkuZSIAbZZdGCwv\nF7OJ7LS9A8pEANosuzDo9QyktFfvlIkAtFnWYZDy6p0yEYA2yz4MUp2wKRMBaLOsw4AyEQCkkXUY\nUCYCgDSyC4Peg+okykQAkEp2YdB7UJ1EmQgAUskyDCgTAUBa2YcBZSIAmFzWYUCZCADSyCoMes8h\nmunuNWUiAEgjqzAozySSKBMBQCpZhUF5JpGUNgwoEwFos+zCoNwzSPnUUspEANos6zCgTAQAaRAG\nXZSJALRZ1mFAmQgA0sgqDOqcTTQ7W7S3vJxm+wDQZFmFQZ2ziWzGDQC0R3ZhUGWZqBwGEuMGANoj\n6zBIdbKOKEKlPGYgpQ0bAGgywkDS4cPFdmf6jgY9AwBtkXUYpLpyH1QikggDAO2RVRhUNZuof1pp\nD9NLAbRFVmFQVZmof1ppefuMGQBog+zCoDy1lDIRAKSRXRhQJgKA9AgDUSYCgOzDgDIRAEwu6zBI\nVcahTASg7bIKg6qmllImAtB2WYXBsNlEEZNtlzIRgLbLLgzKPYOZmeL94cOTbZcyEYC2yzoMpDRX\n75SJALTdVITBpCdsykQA2i77MEhRyqFMBKDtsgqD/tlEEmUiAEghqzDon00kUSYCgBSyCwPKRACQ\nXvZhQJkIACY3FWFAmQgAJpN9GFAmAoDJZRUGzCYCgGokCQPbW20/ZPth29cNWedjtnfavt/2uWtp\nhzIRAFRj4jCwPSPp45LeLOk1kq6yfXbfOpdKekVEvFLSNZI+tZa2Bk0tpUwEAJNL0TM4X9LOiHgk\nIg5Luk3SFX3rXCHps5IUEd+TdILtzeM2xGwiAKjGxtVXWdVpknaV3j+qIiBWWmd3d9meQRu8887i\n5+tfL5100tHl45aJ7r9f2rVr8N/KHntseBg8+eTR/dmwQbr4Ymlu7vnrfutb0tNPr94WAKRw5pnS\nOeek216KMEjuve/dpscfly68ULruuo46nY6k4WGwf//g7Vx5pXTqqdJxx63c3tlnSy9/+fOXb9ok\ndTrSjTcW77/zHen226U3vvG56+3dK11yibR166ofDQAm9pvfLGrz5kWdu6bR18FShMFuSaeX3m/p\nLutf5yWrrPOshx/epve9TzrllOJk3DNoNlHvC24G2b9f+sxnpJe+dJVPMMQxx0hf+MLR95deOjh4\n9u+XTj75aA8CAKrV6b4K27dvn3iLKcYM7pN0pu0zbM9JulLSjr51dkh6hyTZvkDS3ogYWCLqGVT+\nGbdMNGwsYK2GtZW6HQCo28Q9g4hYtn2tpLtUhMtNEfGg7WuKP8eNEfE122+x/TNJ+yS9a7XtLixI\nzzzz3GXDHlQ3bAB52JTRtRrWVup2AKBuScYMIuIbks7qW/bpvvfXjrPNhQXpiSeeu2zcO5AJAwAY\nTWPvQB50kh9nammEdOjQ4Jk/k+zTsDLRoPsUACAXjQ2DSccMDh2SZmelmYSfkJ4BgGnV6DAYpWcw\nrExUxQmaMAAwrRobBoNO8uM8qG7YIyZS71NVbQFAnRobBsPKRKN+7WUV0z2ZWgpgWjU6DCgTAUA9\nGhsGk84mokwEAKNrbBhMOpuIMhEAjK7RYUCZCADq0dgwYDYRANSnsWHAbCIAqE+jw4AyEQDUo7Fh\nwGwiAKhPY8Ng1NlEvfdLS89dTpkIAEbX2DCYny8eNhdxdNmgMOit23+SpkwEAKNrbBjYxVNHyyf5\nQbOJpMEn6brLRIQBgJw1Ngyk55dlhvUMBoVB3WUixgwA5KzxYVA+yQ+aWipRJgKASTU6DPrLMuP0\nDCgTAcDoGh0Gg3oGlIkAIL3Gh8GoYwZ1lIlmZ4t9WF6uvi0AqFOjw6C/LDNsNtGg8k0VZSK7vvEJ\nAKhTo8OgaWWiXlv9YUCZCEDuGh8G/WWiQbOJ6ioT9doa1AuhZwAgZ40Og3L5J2LlqaV1lIlWaosw\nAJCzRodB+Sr8yBFpZqZ4rbReD2UiABhd48Ogd+IdNl7Qv15PXWWiCJ5aCiB/jQ6Dcklm2Eyi/vV6\n6ioTHTpUTDkdVL4CgFw0OgzKV+Gr9QzWq0xEiQjANGh8GJTLRMOuvuuc4dPfFoPHAKZBo8OgXJJZ\nqWcw7EawOspEhAGAadDoMJikTFRnz4AyEYDcNT4MRp1NtJ5jBvQMAOSu8WGwljJRldM9GTMAMI0a\nHQajTi0d9Awje/j6qfZJIgwATIdGh8FaxwyqLN0wtRTANGp8GIwytbS/TFTl1TplIgDTqNFhMOrU\n0jpn+FAmAjCNGh0GlIkAoB6ND4NRppZSJgKAyTQ6DNY6m4gyEQCMp9FhQJkIAOrR+DBgNhEAVK/R\nYcBsIgCoR6PDgDIRANSj8WEw6myiuq7WKRMBmEaNDoNRZxPNzRVhceRI8Z4yEQCMZ6JHudk+SdK/\nSTpD0i8kvT0inhqw3i8kPSXpiKTDEXH+KNvvnXgjVu4Z2EcHkY85hjIRAIxr0p7B+yV9MyLOknSP\npOuHrHdEUicifm/UIJCKk/+GDUUQrDSbSHpu+YYyEQCMZ9IwuELSLd3fb5H01iHrea1t9XoHK/UM\neuv1rtgpEwHAeCYNg00RsUeSIuLXkjYNWS8k3W37Ptt/NU4DvSvx1cKgfMVed5mIMACQu1XHDGzf\nLWlzeZGKk/sHB6weQzbzuoh4zPYpKkLhwYi4d1ib27ZtK7Xf0cGDnbHC4MAB6QUvGL7uJPgOZADr\nbXFxUYuLi0m3uWoYRMSbhv3N9h7bmyNij+0XSXp8yDYe6/78P9tflnS+pJHC4NZbixPuSrOJpOeX\niU45ZYUPNQHKRADWW6fTUafTefb99u3bJ97mpGWiHZKu7v7+Tkl39K9g+1jbx3d/P07SJZJ+NGoD\nTSsTzc9Lhw4VM5yqbgsA6jJpGHxE0pts/1TSRZI+LEm2X2z7q911Nku61/YPJH1X0p0RcdeoDZTD\noAmziWZmpNnZIhB6bVEmApC7ie4ziIgnJF08YPljki7r/v6/ks5daxu98k9TZhP12uq1QZkIwDRo\n9B3IUvPKRL22esFDmQjANJjKMKj6ar2/LcpEAHLX+DDolX/GnU1UR5mo1xY9AwC5a3wY5NAzIAwA\n5G4qw6CuMYOlpeL9SvsFADlofBiUZxOtNLW0v3RTR5mIXgGAadH4MBinZ1AeM6ijTEQYAJgWUxUG\ndZeJ+C4DANOi8WEwzk1nlIkAYG0aHwa9K/7VppZSJgKAtcsmDCgTAUB1sgiDcWYTLS8X687OVrtP\n9AwATJPGh8GoX3vZf7VuV79PhAGAadH4MBi3TFTHg+PKwUMYAJgGjb93tneSjxhtNlEdV+vlMhFj\nBgCmQeN7BqM+qK53tV7HCZoyEYBp0/gwoEwEANXLpky0YcNos4koEwHA+BrfMxj1DuQ6T9CUiQBM\nm8aHwbgPqqNMBADjm6owoEwEAGvT+DAY52svKRMBwNo0PgwoEwFA9aYmDHo9iP37KRMBwLgaHwaj\nfu3lzEwRFr/9LWUiABhX48NgdrYYLzhwYPUvnl9YkJ56ijIRAIyr8WFgFyfcZ54ZLQz27qVMBADj\nanwYSMUJd9++1cNgfr7oGVAmAoDxZBEGCwvS009TJgKAqmQTBlIzy0SEAYBpkEUY9Mo+K80m6q23\nd299ZaL9+xkzADAdsgiDcXoGdZSJNm4sBrb37aNnAGA6EAYT7FNdbQFA1bIIg14pZpTZRHWUiepu\nCwCqlkUYjNMzqGtQt862AKBqWYXBzCp721uvrjCoqy0AqFoWYTA/X8wksldfr/yz6n2qqy0AqFoW\nYbCwsHqJqLde+WeVem3MzVXfFgBUjTBYo4WF4rVabwUAcpBFGMzPjxYGdZeJKBEBmBZZhEGTewYA\nMA0IgzUiDABMkyzCgDIRAFQrizBYWFj9IXW99co/q0TPAMA0ySYMxikT1XHFThgAmCZTFwZzc6vf\nqZxqnygTAZgWE502bb/N9o9sL9s+b4X1ttp+yPbDtq8bt51xxgzqOkHPz9MzADA9Jr2G/qGkP5H0\nn8NWsD0j6eOS3izpNZKusn32OI2M0zOo6wRdR1uLi4vVNpAJjsNRHIujOBZpTRQGEfHTiNgpaaX7\ncM+XtDMiHomIw5Juk3TFOO0QBu3GcTiKY3EUxyKtOsYMTpO0q/T+0e6ykfUeVDfKenWWiRgzADAt\nVr3etn23pM3lRZJC0j9GxJ1V7VjZsceO9kC4Y48tXnWosy0AqJojYvKN2N+S9N6I+P6Av10gaVtE\nbO2+f7+kiIiPDNnW5DsEAC0TERM9NnOESvzIhu3IfZLOtH2GpMckXSnpqmEbmfQDAQDGN+nU0rfa\n3iXpAklftf317vIX2/6qJEXEsqRrJd0l6ceSbouIByfbbQBASknKRACAvDXmDuRJb0zLme0ttu+x\n/WPbP7T9d93lJ9m+y/ZPbf+H7RPWe1/rYnvG9vdt7+i+b+WxsH2C7dttP9j99/H7LT4Wf9+9yfUB\n25+zPdeWY2H7Jtt7bD9QWjb0s9u+3vbO7r+bS0ZpoxFhkOLGtMwtSfqHiHiNpAsl/U33879f0jcj\n4ixJ90i6fh33sW7vkfST0vu2HouPSvpaRJwj6bWSHlILj4XtUyX9raTzIuJ3VYx3XqX2HIubVZwf\nywZ+dtuvlvR2SedIulTSJ+3Vv5OxEWGgBDem5Swifh0R93d/f1rSg5K2qDgGt3RXu0XSW9dnD+tl\ne4ukt0j6l9Li1h0L2y+Q9IcRcbMkRcRSRDylFh6Lrg2SjrO9UdIxknarJcciIu6V9GTf4mGf/XIV\nY7NLEfELSTtVnGNX1JQwmPjGtGlh+6WSzpX0XUmbI2KPVASGpE3rt2e1+mdJ71NxP0tPG4/FyyT9\nxvbN3ZLZjbaPVQuPRUT8StI/SfqlihB4KiK+qRYei5JNQz57//l0t0Y4nzYlDCDJ9vGSvijpPd0e\nQv/o/tSP9tv+Y0l7uj2llbq2U38sVJRCzpP0iYg4T9I+FaWBNv67OFHFlfAZkk5V0UP4c7XwWKxg\nos/elDDYLen00vst3WWt0e36flHSrRFxR3fxHtubu39/kaTH12v/avQ6SZfb/rmkf5X0R7ZvlfTr\nFh6LRyXtioj/7r7/kopwaOO/i4sl/TwinuhOV/+ypD9QO49Fz7DPvlvSS0rrjXQ+bUoYPHtjmu05\nFTem7VjnfarbZyT9JCI+Wlq2Q9LV3d/fKemO/v9o2kTEByLi9Ih4uYp/B/dExF9IulPtOxZ7JO2y\n/aruootU3KvTun8XKspDF9he6A6GXqRigkGbjoX13N7ysM++Q9KV3dlWL5N0pqT/WnXjTbnPwPZW\nFTMnZiTdFBEfXuddqo3t10n6topHgkf39QEV/wO/oCLlH5H09ojYu177WTfbb1DxmJPLbZ+sFh4L\n269VMZA+K+nnkt6lYiC1jcfiBhUXCIcl/UDSX0r6HbXgWNj+vKSOpBdK2iPpBklfkXS7Bnx229dL\nereKY/WeiLhr1TaaEgYAgPXTlDIRAGAdEQYAAMIAAEAYAABEGAAARBgAAEQYAABEGAAAJP0/Xcj9\n5OM4zVYAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "or_set = [((0,0),0), ((0,1),1), ((1,0),1), ((1,1),1)]\n", + "plot_xys(or_set)\n", + "\n", + "(errs,_) = perceptron(or_set,100)\n", + "plt.figure()\n", + "plt.plot(errs)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAEACAYAAABWLgY0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAEACAYAAABRQBpkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xor_set = [((0,0),0), ((0,1),1), ((1,0),1), ((1,1),0)]\n", + "plot_xys(xor_set)\n", + "\n", + "(errs,_) = perceptron(xor_set,100)\n", + "plt.figure()\n", + "plt.plot(errs)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Validation error: 0.02\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEACAYAAACj0I2EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAEACAYAAAC3adEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nPgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "noise_chance = 0.0\n", + "N = 100\n", + "xys = [(uniform(0,10),uniform(0,10)) for _r in range(0,N)]\n", + "secret_f = lambda x: x*2 - 1\n", + "dataset = [(xy,(1 if (secret_f(xy[0]) <= xy[1] or uniform(0,1)= 0 else 0\n", + " error = actual - predicted \n", + " val_net_error += abs(error)\n", + "val_error = val_net_error/len(validation)\n", + "print(\"Validation error:\",val_error)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [Root]", + "language": "python", + "name": "Python [Root]" + }, + "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.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}