diff --git a/projects/1-explications/neil.md b/projects/1-explications/neil.md new file mode 100644 index 0000000..d62f3ca --- /dev/null +++ b/projects/1-explications/neil.md @@ -0,0 +1,18 @@ +# The Google Self Driving Car +Google's self driving cars are developed by Google X, and are impressive autonomous vehicles which operate in line with the rules of the road. They intelligently interpret their environment and react to them by steering, accelerating, or decelerating. + +The project was formerly led by Sebastian Thrun, and is developed by a team of Google engineers. It is simply an attempt to advance autonomous vehicles, and Google X is a good place to lead this research because their labs are dedicated to trying projects which at some point were considered impossible. + +## Knowledge Representation +The Google Car utilizes expensive sensors to generate a 3D view of the world around it. It utilizes this information to form multiple data models of where pedestrians around it are. + +Central concepts based off released information is the car's location, at all times. The team has made it clear that GPS is too inaccurate for their purposes, so it combines data from GPS and it's laser sensor to precisely determine location. + +Other, more peripheral information, is likely information that it filters out. This probably includes objects on the sidewalk (such as people, dogs, people in vehicles, etc) which it predicts are not going to affect it's driving abilities. + +## Interaction With Humans +The car is designed to be used by human passengers, and is meant to avoid hitting other objects while efficiently moving the passenger from point A to point B. It assumes that the human will not try to do anything in the car to alter the driving (latest revisions of the car do not include steering wheel or pedals), and it also assumes that the human will be content with preset rules of the car (max speed, route, etc). + + +### Malicious User Interaction +A hostile user could probably try to damage the car and steal one of the sensors (which are extremely expensive), or possibly try to weigh down the car and mess with its expectations. To injure others, a user might be able to take control of the vehicle using a steering wheel and override a decision made by the Google car. Indeed, Google claims that a few of it's accidents were caused by the driver, not the car itself. This isn't anything more than manually causing harm, but it raises doubt on the accuracy of autonomous vehicles. A hostile user from outside the car could do something that it has never experienced (and thus cannot react to), such as jumping from the sidewalk in front of the car, taping a sensor while it's stopped, or trying to drive head on into the Google car. I doubt that the Google car is prepared for any of these cases (except possibly a malfunctioning sensor). diff --git a/projects/1-hello-world/neil.ipynb b/projects/1-hello-world/neil.ipynb new file mode 100644 index 0000000..8415592 --- /dev/null +++ b/projects/1-hello-world/neil.ipynb @@ -0,0 +1,79 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "# Introduction\n", + "Hello, my name is Neil. \n", + "## Background In Programming and AI\n", + "I've been into programming for a about 6-7 years now. I started off with copying tutorials line by line. I don't know which language or what I made exactly, I just recall following Youtube tutorials for hours. Then I moved onto Java, making plugins for a game (Minecraft). I slowly became more proficient with it, and eventually took AP Computer Science and got a 5. I learned a lot by trying (and usually failing) in attempting to make projects/networks with friends, and intend to be a programmer in the future as a career choice.\n", + "\n", + "As for AI, I got interested in it over the summer last year, and chose it for my Math Research. I explored the very basics of ML, creating a linear regression using gradient descent (simple, but at least it's simple enough for me to verify). I made it such that I could easily expand it later into multiple dimensions. I also created a basic genetic algorithm in Java, and have played with some Python libraries to make a basic neural network. \n", + "\n", + "\n", + "## What I Hope to Gain From This Course\n", + "I hope to become more familiar with using the various tools in ML/AI, rather than implementing them by hand. I did that for my research, and it was not fun (especially with it only accomplishing something as simple as linreg).\n", + "\n", + "I also hope to gain some inspiration for my next year research project, which is going to be ML/AI applied to some field of science. I currently am looking for an idea which is novel and will be genuinely interesting to look into.\n", + "\n", + "\n", + "## Favorite Hobbies Outside of Programming (and computing)\n", + "I like playing videogames. A lot. I have over 1000 hours in Counter Strike: Global Offensive, and recently started playing Overwatch.\n", + "\n", + "Outside of computers completely, I enjoy badminton and watching movies with friends. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "print(1==1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/projects/2-state-machines/neil.ipynb b/projects/2-state-machines/neil.ipynb new file mode 100644 index 0000000..845219f --- /dev/null +++ b/projects/2-state-machines/neil.ipynb @@ -0,0 +1,543 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Background" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "State machines, like most transition systems, are defined in terms of their set of states, their initial state, their terminal states, and the valid transitions between the states. State machines are still used widely in game character AI, but they also show up in various guises all over computer science (for example in regular expressions, program verification, cyber-physical systems, ...). A solid understanding of transition systems is key to understanding many different research areas.\n", + "\n", + "Today's assignment is to use state machines in a couple of different ways to get used to reading and writing Python code, and to get a feel for what can be done with state machines.\n", + "\n", + "First, we want to create a data type to represent state machines. In Python, the custom data type is the `class`. We know that it will be initialized with a set of states and edges, an initial state, and some terminal states, and creating a state machine should look something like:\n", + "\n", + "```python\n", + "ab_a_ = StateMachine(\n", + " #We can define the states and edges in one go\n", + " [(\"s1\", \"a\", \"s2\"), (\"s2\", \"b\", \"s3\"), (\"s3\", \"a\", \"s3\")],\n", + " #Initial state\n", + " \"s1\",\n", + " #Terminal states\n", + " [\"s3\"]\n", + ")\n", + "```\n", + "\n", + "To recap:\n", + "\n", + "* `ab_a_ = ...` assigns the result of evaluating the right hand side to the variable `ab_a_`.\n", + "* `StateMachine(...)` creates a new object of the StateMachine class\n", + "* `[...]` is a comma-separated list of arbitrary \"things\". This list could grow or shrink but the key idea is that its length is unknown in advance to the code that's processing it (usually necessitating some kind of iteration or recursion over the length of the list).\n", + "* `(...)` without a word to its left is a \"tuple\", a fixed-length sequence of objects. Here, each 3-tuple defines the source state, the transition symbol, and the target state. (If there were a word to the left of the parentheses, it would be a function call as in the case of `StateMachine(...)`).\n", + "* `\"...\"` is a \"string\", a sequence of characters.\n", + "\n", + "Putting it all together, the line above makes a machine with three states that accepts `aba+`, if written as a regular expression (and stores the machine into the variable `ab_a_`): any string with the prefix `ab` followed by one or more `a`. Here's `ab(cab)+d`, `ab` followed by one or more repetitions of `cab` ending with a `d`:\n", + "\n", + "```python\n", + "ab_cab_d = StateMachine(\n", + " [(\"s1\", \"a\", \"s2\"),\n", + " (\"s2\", \"b\", \"s3\"), # The same so far...\n", + " (\"s3\", \"c\", \"s4\"),\n", + " (\"s4\", \"a\", \"s5\"),\n", + " (\"s5\", \"b\", \"s6\"),\n", + " (\"s6\", \"c\", \"s4\"), # Note the loop back to s4 on \"c\"\n", + " (\"s6\", \"d\", \"s7\")], # Or else the continuation to s7 on \"d\"\n", + " \"s1\",\n", + " [\"s7\"]\n", + ")\n", + "```\n", + "\n", + "We have two questions of interest for any transition system:\n", + "\n", + "* What is the current configuration?\n", + "* What configurations are accessible from the current configuration, and how?\n", + "\n", + "In our case, we can use e.g. `ab_a_.state` to get its current state identifier, and `ab_a_.out_edges()` to get a Python `dict` of the successors (with `ab_a_.out_edges().keys()` yielding the symbols and the `ab_a_.out_edgdes().values()` giving the successor states).\n", + "\n", + "There is one operation on state machines that we're interested in right now:\n", + "\n", + "* Advance the state machine along a particular available edge.\n", + "\n", + "We can write e.g. `ab_a_.advance(\"a\")` to advance the `ab_a_` machine by feeding it the symbol `\"a\"`. If it starts in state `\"s1\"`, this will put it into state `\"s2\"`. Then we can call `ab_a_.advance(\"b\")` to feed it a `\"b\"` and advance it to `\"s3\"`, and so on. It is an error to call `advance` with an unavailable or invalid symbol.\n", + "\n", + "Now that we know what the StateMachine class should look like, we can define it. Recall that Python is indentation-sensitive:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "class StateMachine:\n", + " # __init__ defines the function to be called when `StateMachine(...)` is invoked.\n", + " # Note that, like other instance methods on `StateMachine`, the first argument is `self`:\n", + " # the particular state machine being operated upon (in this case, initialized). `self` is\n", + " # provided implicitly in most cases.\n", + " # `edges` should be a list of 3-tuples of strings, init-state should be a string, and terminals a list of strings.\n", + " def __init__(self, edges, init_state, terminals):\n", + " # We create a `states` variable on `self` to store the transition system information.\n", + " # It will be a dict whose keys are state identifiers and whose values are themselves dicts\n", + " # of successor states keyed by symbols.\n", + " self.states = dict()\n", + " # `for X in C` iterates over each member `X` of collection `C`.\n", + " # Since we know `C` (`edges`) contains 3-tuples, we can \"unpack\" them using the tuple notation in place of `X`.\n", + " for (src, symbol, dest) in edges:\n", + " # Ensure that the state referred to by `src` exists in the transition system as a dict (again, symbols->states):\n", + " if src not in self.states:\n", + " self.states[src] = dict()\n", + " # Ditto for `dest`.\n", + " if dest not in self.states:\n", + " self.states[dest] = dict()\n", + " # Ensure that the symbol is not already used in an out-edge of src. This is a deterministic state machine which\n", + " # can't make \"guesses\" in such cases.\n", + " if symbol in self.states[src]:\n", + " # Exceptions are informative failures that other code can catch and deal with; they represent exceptional\n", + " # cases which this code is not in a position to recover from.\n", + " raise Exception(\"This StateMachine only supports DFAs, so each state can have at most one out edge for each symbol.\")\n", + " # Finally, connect the `s`ou`rc`e state to the `dest`ination state along `symbol`.\n", + " self.states[src][symbol] = dest\n", + " # This state machine starts in the initial state\n", + " self.state = init_state\n", + " # And we remember the terminal states so that we know when we're accepting.\n", + " # The list is packed into a `set()`, which permits us to say `state_id in self.terminal_states` to simplify checking.\n", + " # You can think of sets as being like dicts of type Anything->True: \n", + " # The object is in the set if and only if the key is present.\n", + " self.terminal_states = set(terminals)\n", + "\n", + " # Determining the available out-edges is straightforward because of the way we've chosen to represent the\n", + " # transition system.\n", + " def out_edges(self):\n", + " # Return the out edges of the currently active state.\n", + " return self.states[self.state]\n", + " \n", + " # A state machine is in a terminal state if its current state is terminal\n", + " def is_terminal(self):\n", + " # Is the current state in the set of terminal states?\n", + " return self.state in self.terminal_states\n", + "\n", + " # A state machine is stuck if it has no out edges.\n", + " def is_stuck(self):\n", + " return len(self.out_edges()) == 0\n", + " \n", + " # Finally, to advance the state machine by a symbol...\n", + " def advance(self, symbol):\n", + " # We reassign the machine's state to be the target state denoted by that symbol, among the current out edges.\n", + " self.state = self.out_edges()[symbol]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With all that done, we can finally say:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "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", + " [(\"s1\", \"a\", \"s2\"), (\"s2\", \"b\", \"s3\"), (\"s3\", \"a\", \"s3\")],\n", + " #Initial state\n", + " \"s1\",\n", + " #Terminal states\n", + " [\"s3\"]\n", + ")\n", + "print(\"Initial state:\", ab_a_.state) # note, no parens after `state` because it's a value field and not a function\n", + "print(\"Accepting?\", ab_a_.is_terminal()) # parens after `is_terminal` to _call_ it.\n", + "ab_a_.advance(\"a\")\n", + "print(\"After a:\", ab_a_.state)\n", + "ab_a_.advance(\"b\")\n", + "print(\"After ab:\", ab_a_.state)\n", + "print(\"Next steps:\", ab_a_.out_edges())\n", + "print(\"Accepting?\", ab_a_.is_terminal())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Assignment 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The first part of the assignment is to define the function `check(...)` below:" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def test1():\n", + " # This one accepts \"h(e(llo|y) | i(hi)*)\n", + " return StateMachine(\n", + " [(\"s1\", \"h\", \"s2\"), (\"s2\", \"e\", \"s3\"), \n", + " (\"s3\", \"y\", \"s4\"), \n", + " (\"s3\", \"l\", \"s5\"), (\"s5\", \"l\", \"s6\"), (\"s6\", \"o\", \"s7\"),\n", + " (\"s2\", \"i\", \"s8\"), (\"s8\", \"h\", \"s9\"), (\"s9\", \"i\", \"s8\")\n", + " ],\n", + " \"s1\",\n", + " [\"s4\", \"s7\", \"s8\"]\n", + " )\n", + "\n", + "\n", + "def check(sm, string):\n", + " for sym in string:\n", + " if sym in sm.out_edges().keys():\n", + " sm.advance(sym)\n", + " else:\n", + " return False\n", + " if sm.is_terminal():\n", + " return True\n", + " return False\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It should give the correct results for at least these examples, and we encourage you to try out more tests." + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Test suite 1. Should not throw any errors.\n", + "# (First, we define a function to produce the test state machine so we can use a fresh one every time.)\n", + "def test1():\n", + " # This one accepts \"h(e(llo|y) | i(hi)*)\n", + " return StateMachine(\n", + " [(\"s1\", \"h\", \"s2\"), (\"s2\", \"e\", \"s3\"), \n", + " (\"s3\", \"y\", \"s4\"), \n", + " (\"s3\", \"l\", \"s5\"), (\"s5\", \"l\", \"s6\"), (\"s6\", \"o\", \"s7\"),\n", + " (\"s2\", \"i\", \"s8\"), (\"s8\", \"h\", \"s9\"), (\"s9\", \"i\", \"s8\")\n", + " ],\n", + " \"s1\",\n", + " [\"s4\", \"s7\", \"s8\"]\n", + " )\n", + "assert check(test1(), \"hello\")\n", + "assert check(test1(), \"hey\")\n", + "assert check(test1(), \"hi\")\n", + "assert check(test1(), \"hihi\")\n", + "assert check(test1(), \"hihihi\")\n", + "assert not check(test1(), \"greetings\")\n", + "assert not check(test1(), \"hel\")\n", + "assert not check(test1(), \"helloy\")\n", + "assert not check(test1(), \"hih\")\n", + "assert not check(test1(), \"heyhey\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "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)." + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def test2():\n", + " # NOTE: Commented transitions allow emails ending in .co.uk, and '.'s in the beginning of the email. \n", + " # They are disabled because future code depends on it\n", + " return StateMachine([(\"s0\", \"x\", \"s1\"), (\"s1\", \"x\", \"s1\"),\n", + " (\"s1\", \"@\", \"s2\"), (\"s2\", \"x\", \"s3\"), (\"s3\", \"x\", \"s3\"), (\"s3\", \".\", \"s4\"), (\"s4\", \"x\", \"s5\"), (\"s5\", \"x\", \"s5\"), \n", + " #(\"s5\", \".\", \"s4\"),\n", + " (\"s1\", \".\", \"s6\"), (\"s6\", \"x\", \"s7\"), \n", + " #(\"s7\", \".\", \"s6\")\n", + " (\"s7\", \"x\", \"s7\"), (\"s7\", \"@\", \"s2\") \n", + " ],\n", + " \"s0\",\n", + " [\"s5\"])\n", + "\n", + "assert not check(test2(), \"x@x\")\n", + "assert not check(test2(), \"x\")\n", + "assert not check(test2(), \"x@.\")\n", + "assert not check(test2(), \"@x.\")\n", + "assert not check(test2(), \"xxxx\")\n", + "assert not check(test2(), \"x@x.\")\n", + "assert not check(test2(), \"x@.x\")\n", + "assert not check(test2(), \"x.@x\")\n", + "assert not check(test2(), \"x@@x\")\n", + "assert not check(test2(), \"x..x@x.x\")\n", + "assert not check(test2(), \".x@x.x\")\n", + "assert not check(test2(), \"@x.x\")\n", + "assert check(test2(), \"xxx@xxx.xxx\")\n", + "#assert check(test2(), \"x.x@xxx.xxx\")\n", + "#assert check(test2(), \"x.x.x@xxx.xxx\")\n", + "#assert check(test2(), \"x.x.x.x.x.x.x@xxx.xxx\")\n", + "#assert check(test2(), \"x@x.x.x\") # British and Japanese emails: co.uk and co.jp\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Assignment 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define a function which, given a state machine, generates all the strings of a given (exact) length that the state machine would accept.\n", + "\n", + "If you have an intuition on how to do this, feel free to try it! Insert your attempt and its tests in the empty code cell just after this one. Then come back and take a look at the approach below." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def try_sample(sm, length):\n", + " return []" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that any path through a state machine ending in a terminal state is a valid string, and each step of the path is associated with a symbol (i.e., a letter). To combine symbols together into strings, you can use string concatenation:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "ab = \"a\" + \"b\"\n", + "ab+= \"c\"\n", + "print(ab)\n", + "abc = ab + \"c\"\n", + "print(abc)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can combine lists the same way:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "lst_abc = [\"a\",\"b\"] + [\"c\"]\n", + "print(lst_abc)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All that's left is enumerating the valid paths of a given length and assembling those into strings. The skeleton below is a _recursive_ function that calls itself repeatedly, branching out according to each option. You can imagine that the call to `sample()` is the root of a tree of calls to `sample2`, and the paths through that tree are paths through the state machine---the path itself is \"stored\" in the third argument to `sample2`. In other words:\n", + "\n", + "* To get the possible paths of length `K` from a state machine `SM`:\n", + " * Initialize `S` to `SM`'s current state.\n", + " * Initialize the `result` to `[]`\n", + " * For each available out-edge at `S`:\n", + " * Advance `SM` along that edge\n", + " * Get the possible paths of length `K-1` from `SM` and add them to the result\n", + " * Put `SM` back into state `S` (so we can advance it along the next available out edge)\n", + " * Yield `result`\n", + "\n", + "It's up to you to figure out how to find the possible paths of length 0. Hint: How many such paths can there be for a given call to `sample2(sm, 0, sofar)`? What aspects of the state machine's status does it depend on?" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "#def DFS(sm, node):\n", + " # for(edge in sm.out_edges)\n", + "\n", + "# Starter function that calls sample2() with an empty string as argument. This is just to \"accumulate\" paths into\n", + "# that argument without tracking a bunch of data externally.\n", + "def sample(sm, length):\n", + " return sample2(sm, length, \"\")\n", + "\n", + "# sample2 samples paths of length \"length\" from the state machine sm as of its current state.\n", + "# sofar is the path assembled so far.\n", + "# sample2 returns a list of paths.\n", + "def sample2(sm, length, sofar):\n", + " if length == 0:\n", + " # TODO: What path(s) should be returned? When?\n", + " #if(len(sm.states) == 1):\n", + " if sm.is_terminal():\n", + " return [sofar]\n", + " else: \n", + " return []\n", + " # elif(len(sm.states)==0):\n", + " # raise Exception(\"Cannot do a search on a SM without any nodes defined.\")\n", + " state = sm.state\n", + " result = []\n", + " # TODO: implement the rest of the pseudocode above\n", + " for edge in sm.out_edges():\n", + " sm.advance(edge)\n", + "\n", + " #path_from_edge = sample2(sm, length-1, sofar)\n", + " result += sample2(sm, length -1, sofar + edge)\n", + " sm.state = state\n", + " \n", + " return result" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['x@x.x', 'x@x.xx', 'x@xx.x', 'xx@x.x', 'x@x.xxx', 'x@xx.xx', 'x@xxx.x', 'x.x@x.x', 'xx@x.xx', 'xx@xx.x', 'xxx@x.x', 'x@x.xxxx', 'x@xx.xxx', 'x@xxx.xx', 'x@xxxx.x', 'x.x@x.xx', 'x.x@xx.x', 'x.xx@x.x', 'xx@x.xxx', 'xx@xx.xx', 'xx@xxx.x', 'xx.x@x.x', 'xxx@x.xx', 'xxx@xx.x', 'xxxx@x.x']\n" + ] + } + ], + "source": [ + "assert len(sample(test2(), 0)) == 0\n", + "assert len(sample(test2(), 1)) == 0\n", + "assert len(sample(test2(), 2)) == 0\n", + "assert len(sample(test2(), 3)) == 0\n", + "assert len(sample(test2(), 4)) == 0\n", + "assert len(sample(test2(), 5)) == 1\n", + "assert len(sample(test2(), 6)) == 3\n", + "assert len(sample(test2(), 7)) == 7\n", + "assert len(sample(test2(), 8)) == 14\n", + "\n", + "all_samples = []\n", + "for i in range(0, 9):\n", + " all_samples = all_samples + sample(test2(), i)\n", + "print(all_samples)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# What's next?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you like (and have time), define more test state machines in new test cells (test3, test4, etc). What types of string are easy to recognize, and which seem hard---or even impossible? You might want to try some of these and determine whether they're possible within the limits of state machines:\n", + "\n", + "* Phone numbers\n", + "* URLs\n", + "* Palindromes\n", + "* HTML tags\n", + "* English-language numbers (e.g. \"seventy-one\", \"nineteen\", \"six\", \"one hundred and one\")\n", + "* Roman numerals\n", + "\n", + "Another (bigger) project might be to write a regular expression compiler to generate state machines from regular expressions---even just supporting concatenation and Kleene star would be a fun exercise for an evening!\n", + "\n", + "If you have an interest in the theory behind computer science, you might want to implement a non-deterministic automaton which can be in (or start in) several states simultaneously, may have out-edges to multiple distinct states on a given symbol, or may even have \"null\" or \"epsilon\" transitions which can be taken without consuming any input at all! Another good project here might involve taking the intersection or union of two languages (by manipulating their state machines)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/projects/3-mazes/Maze Solvers.ipynb b/projects/3-mazes/Maze Solvers.ipynb index 96f4aee..19bb7db 100644 --- a/projects/3-mazes/Maze Solvers.ipynb +++ b/projects/3-mazes/Maze Solvers.ipynb @@ -499,7 +499,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.1" + "version": "3.5.2" } }, "nbformat": 4, diff --git a/projects/3-mazes/maze.py b/projects/3-mazes/maze.py new file mode 100644 index 0000000..e69de29 diff --git a/projects/3-mazes/neil.ipynb b/projects/3-mazes/neil.ipynb new file mode 100644 index 0000000..21a6d14 --- /dev/null +++ b/projects/3-mazes/neil.ipynb @@ -0,0 +1,808 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we load up some useful libraries for visualization and data structures." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "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", + "#from heapq import heappush, heappop\n", + "try:\n", + " import Queue as Q # ver. < 3.0\n", + "except ImportError:\n", + " import queue as Q\n", + "import numpy\n", + "import functools" + ] + }, + { + "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": 51, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 0)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQkAAAEACAYAAACgZ4OsAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "@functools.total_ordering\n", + "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", + " self.player_alive = True\n", + " self.path = [] # Paths to get to this state\n", + " self.cost = 0\n", + " for y in range(0,height):\n", + " assert len(self.grid[y]) == width, \"All rows must be equal length!\"\n", + " for x in range(0,width):\n", + " c = self.grid[y][x]\n", + " assert c == \"#\" or c == \".\" or c == \"!\" or c == \"?\" or c == \"@\" or c.isalnum()\n", + " if c.lower() == \"x\":\n", + " assert self.exit_pos == None\n", + " self.exit_pos = (x,y)\n", + " if c == \"@\":\n", + " assert self.player_pos == None\n", + " self.player_pos = (x,y)\n", + " self.grid[y][x] = \".\"\n", + " \n", + " def clone(self):\n", + " return copy.deepcopy(self)\n", + " \n", + " def toggle_cell(self,switchnum,c):\n", + " if c.isalpha() and Maze.SwitchMap[switchnum] == c.lower():\n", + " if c.islower():\n", + " return c.upper()\n", + " else:\n", + " return c.lower()\n", + " return c\n", + " \n", + " def toggle(self):\n", + " assert self.player_alive\n", + " height = len(self.grid)\n", + " width = len(self.grid[0])\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 self.grid[y][x] == 'X':\n", + " return True\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", + " if not self.is_free(newx, newy):\n", + " return False\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", + " \n", + " \n", + " def available_moves_from_point(self, point):\n", + " if not self.player_alive:\n", + " return []\n", + " (x,y) = point\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", + " valid_set = [(-1,0),(1,0),(0,-1),(0,1)]\n", + " ret_val = []\n", + " for (dx,dy) in valid_set:\n", + " if self.is_free(x+dx, y+dy):\n", + " ret_val.append((dx,dy))\n", + " return ret_val\n", + " # [\"switch\"] if can_switch else []\n", + " #)\n", + " \n", + " def __hash__(self):\n", + " return hash(str(self.grid)) % 1000007 + hash(self.player_pos) % 1000007 + hash(self.player_alive) % 1000007\n", + " \n", + " def _is_valid_operand(self, other):\n", + " return (hasattr(other, \"grid\") and hasattr(other, \"player_pos\") and hasattr(other, \"player_alive\"))\n", + " \n", + " def __eq__(self, other):\n", + " if not self._is_valid_operand(other):\n", + " return NotImplemented\n", + " return ((self.grid, self.player_pos, self.player_alive) ==\n", + " (other.grid, other.player_pos, other.player_alive))\n", + " \n", + " def __lt__(self, other):\n", + " if not self._is_valid_operand(other):\n", + " return NotImplemented\n", + " return ((self.grid, self.player_pos, self.player_alive) <\n", + " (other.grid, other.player_pos, other.player_alive))\n", + " def draw_path(self, path):\n", + " for (x, y) in path:\n", + " self.grid[y][x] = \"g\"\n", + " \n", + " # def __lt__(self, other):\n", + " # if self==other: return False\n", + " # return id(self) < id(other)\n", + " \n", + " def is_at_exit(self):\n", + " return self.player_alive and self.player_pos == self.exit_pos\n", + "\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", + "\n", + "print(sample.player_pos)\n", + "#sample.move_player(0,1)\n", + "#print(sample.available_moves())\n", + "#sample.toggle()\n", + "\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": 52, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def manhattan_distance(point_a, point_b):\n", + " (x0,y0) = point_a\n", + " (x1,y1) = point_b\n", + " return abs(y1-y0) + abs(x1-x0) \n", + "\n", + "def element_wise_tuple_addition(x, y):\n", + " z = []\n", + " for i in range(len(x)):\n", + " z.append(x[i] + y[i])\n", + " return tuple(z)\n", + "\n", + "\n", + "def heuristic(maze):\n", + " frontier = Q.PriorityQueue()\n", + " \n", + " frontier.put((0, maze))\n", + " #came_from = {}\n", + " #cost_so_far = {}\n", + " \n", + " #came_from[start] = None\n", + " #cost_so_far[start] = 0\n", + " visited = set([maze])\n", + " \n", + " while not frontier.empty():\n", + " (priority, current) = frontier.get() # Maze\n", + " \n", + " #print(current)\n", + " \n", + " #print(current.available_moves())\n", + " if current.is_at_exit():\n", + " print(\"Returning path because at \" + str(current.player_pos) + \" while goal is \" + str(current.exit_pos))\n", + " current.path.pop()\n", + " return current.path\n", + "\n", + " for move in current.available_moves():\n", + " #print(\"Checking move \" + str(move))\n", + " \n", + " successor = current.clone()\n", + " \n", + " if move == \"switch\":\n", + " #print(\"Switching at \" + str(successor.player_pos))\n", + " successor.toggle()\n", + " \n", + " \n", + " \n", + " #print(\"Successfully toggled\")\n", + " else:\n", + " (x,y) = move\n", + " successor.move_player(x,y)\n", + " \n", + " #if not current in cost_so_far:\n", + " #print(\"Not found, defaulting to 1\")\n", + " #cost_so_far[current] = 1\n", + " \n", + " #new_cost = cost_so_far[current] + 1\n", + " new_cost = current.cost + 1\n", + " \n", + " if not successor in visited or new_cost < current.cost:\n", + " #cost_so_far[current] = new_cost\n", + " priority = new_cost + manhattan_distance(successor.player_pos, successor.exit_pos)\n", + " \n", + " successor.cost += 1\n", + " successor.path.append(successor.player_pos)\n", + " \n", + " frontier.put((priority, successor))\n", + " visited.add(successor)\n", + " #came_from[current] = successor\n", + "\n", + " \n", + " return []\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOIAAAEACAYAAACu66rqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAADghJREFUeJzt3X+MHHd5x/H35+LEd+drTrTYKcXEJKqsBBTkRG6IMCFQ\nAw2hSoWlCgJS5KhK/yiVI1oDIf+Q/NFKgBCN1EpVBMQkNbSKe1ZSgcAhESBcNST+lSM+hzY/Gick\nthHG1tkOxPbTP3ZcmfOdd+48382zN5+XdLrd0+z3+8yuP57Zmd1nFBGY2etr4PUuwMwcRLMUHESz\nBBxEswQcRLMEHESzBGoFUdJtksarn3WlizJrm65BlPR24C+AlcAK4E8lXVq6MLM2qbNFvBx4LCJ+\nHREngB8Ba8qWZdYudYL4U+BaSW+QNAzcALylbFlm7bKg2wIRsUfSF4CHgUlgB3CidGFmbaLZftZU\n0t8BeyPin6f83R9aNZtGRKjbMl23iACSFkfEAUkXAx8BrpluuQ1rrphdhbOwefc+PvK2i4qN7zly\nzTEf1gFg7dh4reVqBRH4d0m/C7wG/FVEHJ5rYWZ2plpBjIj3lC7ErM365pM1ly1e5DlaNMd8WIfZ\nmPXBmhkHkqLke0SzfrR2bLzWwZq+2SKazWcOolkCDqJZAg6iWQIOolkCDqJZAg6iWQIOolkCDqJZ\nAg6iWQIOolkCDqJZAg6iWQIOolkCdRsMf07SU5KelLRR0gWlCzNrkzoNhpcBtwJXRsQ76Hyr/2Ol\nCzNrkzqtMg4DvwEWSToJDAM/L1qVWct03SJGxEHgy8ALwEvAryLi+6ULM2uTrlvE6joXnwKWAYeA\nTZI+HhHfnLrs5t37/v/2ZYsXcfnikcYKXfe9CQ4fOd7YeNMZGhzk2KuvFp1jyegIX1x9SdE5PvPI\nc+w/NFl0jqGhQY4dK/dclR4fyrwWEwcm2XPgyKwfV2fXdCWwNSJ+CSBpDHgXcEYQS/aIPHzkONxZ\nbHgAjt35Kk318JmJ1LV9yTnbf2iyJ+tRco7S45+ao2mXLx75rQ3Qg3v213pcnaOmTwPXSBpUp/LV\nwMRcijSz6dV5j7gLuA/YBuwCBNxTuC6zVqnbYPhLwJcK12LWWv5kjVkCDqJZAg6iWQIOolkCDqJZ\nAg6iWQIOolkCDqJZAg6iWQIOolkCDqJZAg6iWQIOolkCDqJZAg6iWQIOolkCdfqaLpe0Q9L26vch\nSet6UZxZW3T9hn5E/Ay4EkDSAPAisLlwXWatMttd0/cDz0TE3hLFmLXVbIP4UeBbJQoxa7NazaMA\nJJ0P3AjcPtMyJRsM63yIOxsbbloLBxcW7zu6ZLS552QmQ0ODxddjcLDsHKXHh87z1LSSDYZP+RCw\nLSIOzLRAyQbD8Ro9aTi7Yc0VRefohWPHetMoueRztXZs3A2GZ3AT3i01K6Lu9RGH6RyoGStbjlk7\n1W0wfBRYXLgWs9byJ2vMEnAQzRJwEM0ScBDNEnAQzRJwEM0ScBDNEnAQzRJwEM0ScBDNEnAQzRJw\nEM0ScBDNEnAQzRJwEM0ScBDNEqj7Df1RSQ9ImpD0lKR3li7MrE3qNo+6G/hORPy5pAXAcMGazFqn\naxAlXQhcGxFrASLiOHC4cF1mrVJn1/QS4BeS7q2uf3GPpKHShZm1SZ1d0wXAVcAnI+IJSf9Ap8nw\n56cuWLLBcC+a5pZoODvVZx55jv2HJovO0a/NeaeO34/rULLB8IvA3oh4orq/CfjsdAuWbDDcq6a5\npe0/NNmT9ej356pfX+9iDYYjYh+wV9Ly6k+rgd1zqNHMZlD3qOk6YGN1/YtngVvKlWTWPnUbDO8C\n/qhwLWat5U/WmCXgIJol4CCaJeAgmiXgIJol4CCaJeAgmiXgIJol4CCaJeAgmiXgIJol4CCaJeAg\nmiXgIJol4CCaJVDr+4iSngcOASeB1yLi6pJFmbVN3W/onwTeGxEHSxZj1lZ1d001i2XNbJbqhiuA\nhyU9LunWkgWZtVHdXdNVEfGypMV0AjkRET8uWZhZm9RtHvVy9fuApM3A1cAZQez3BsODg4OsHRsv\nPkcv1qMfm/NOHb8f16FYg2FJw8BARExKWgR8ELhrumXnQ4Nhz1F/jpLa1mC4zhbxImCzpKiW3xgR\nW+ZSpJlNr2sQI+I5YEUPajFrLZ+SMEvAQTRLwEE0S8BBNEvAQTRLwEE0S8BBNEvAQTRLwEE0S8BB\nNEvAQTRLwEE0S8BBNEvAQTRLwEE0S8BBNEugdhAlDUjaLumhkgWZtdFstoi3AbtLFWLWZrWCKGkp\ncAPw1bLlmLVT3S3iV4BP02k0bGYN6xpESR8G9kXETjqt98v20TNroTrtFFcBN0q6ARgCfkfSfRFx\n89QF50OD4V40tZ0P61G6GXO/Nkku1mA4Iu4A7gCQdB3wt9OFEOZHg+ENa64oOkcvrB0b7/smxv3a\nJHmuDYZ9HtEsgboXoQEgIn4I/LBQLWat5S2iWQIOolkCDqJZAg6iWQIOolkCDqJZAg6iWQIOolkC\nDqJZAg6iWQIOolkCDqJZAg6iWQIOolkCDqJZAg6iWQJdvxgsaSHwI+CC6ufBqn2GmTWkTs+aX0t6\nX0QclXQesFXSqojY2oP6zFqh1q5pRBytbi6sHnOwWEVmLVS30/eApB3AK8APIsKt980aVKt5VESc\nBK6UdCGwRdJ1VSOp3zIf+pqW7NUJsGR0hC+uvqToHPOhd2ov+pouGW3u3+cpxfqani4iDkv6NrCS\nabq5zYe+pv3YS3Oq+fBc9WuP2WJ9TSW9UdJodXsI+ACwc25lmtl06mwR3wR8Q53/ygeA+yPikbJl\nmbVLndMX48BVPajFrLX8yRqzBBxEswQcRLMEHESzBBxEswQcRLMEHESzBBxEswQcRLMEHESzBBxE\nswQcRLMEHESzBBxEswQcRLMEHESzBOq0ylgq6VFJT0kal7SuF4WZtUmdVhnHgb+JiJ2SRoBtkrZE\nxJ7CtZm1RtctYkS8EhE7q9uTwATw5tKFmbXJrN4jSnorsAJ4rEQxZm1Vu69ptVu6Cbit2jKeoWSD\n4SWjI33fNBc6zX9Lmw8NhtevX8/zI803AD7d0SNHeNsz3210zKINhiUtoBPC+yPiwZmWK9lguHR3\nbIC1Y+NuMFxT6QbDd911V7GxTxletKjxMYs1GK58HdgdEXfPvjQz66bO6YtVwCeAP5a0Q9J2SdeX\nL82sPeo0GN4KnNeDWsxay5+sMUvAQTRLwEE0S8BBNEvAQTRLwEE0S8BBNEvAQTRLwEE0S8BBNEvA\nQTRLwEE0S8BBNEvAQTRLwEE0S8BBNEugzjf0vyZpn6Qne1GQWRvV2SLeC/xJ6ULM2qxOg+EfAwd7\nUItZa/k9olkCtRsM11GywXAv9KKJ8ZLR8s9JL9ajdBPj9evXM9KDBsNNm2uDYdVpEitpGfAfEfGO\nsywTG9ZcMesCzOazqml11/+x6u6aqvoxswLqnL74JvCfwHJJL0i6pXxZZu1Sp8Hwx3tRiFmb+aip\nWQIOolkCDqJZAg6iWQIOolkCDqJZAg6iWQIOolkCDqJZAg6iWQIOolkCDqJZAg6iWQIOolkCDqJZ\nArWCKOl6SXsk/UzSZ0sXZdY2db6hPwD8I53epm8HbpJ0WenCppo4MOk5WjTHfFiH2aizRbwa+O+I\n+N+IeA34V+DPypZ1prl0xvIc/TvHfFiH2agTxDcDe0+7/2L1NzNriA/WmCXQta+ppGuAOyPi+ur+\n7UBExBemLNe9QapZC9Xpa1oniOcBTwOrgZeBnwA3RcREE0WaWb12iick/TWwhc6u7NccQrNm1Wq5\nb2ZlnfPBmtIn+3txoVRJSyU9KukpSeOS1hWYY6GkxyTtqOb5+6bnqOYZkLRd0kOFxn9e0q5qPX5S\naI5RSQ9Imqieq3c2PP7yqv7t1e9DTb/mkj5X1f6kpI2SLjjrAyJizj90gvw/wDLgfGAncNm5jDnN\nHO8GVgBPNjnulDl+H1hR3R6h85640fWoxh6ufp8H/BewqsAcnwL+BXio0HP1LPCGUq9FNccG4Jbq\n9gLgwoJzDQA/B97S4JjLqufpgur+vwE3n+0x57pFLH6yP3pwodSIeCUidla3J4EJCpwrjYij1c2F\ndP4BNLpekpYCNwBfbXLcqdNQ8LSXpAuBayPiXoCIOB4Rh0vNB7wfeCYi9nZdsr7DwG+ARZIWAMN0\nwj6jc31C593JfklvpbMFfqzA2AOSdgCvAD+IiN0NT/EV4NNAyTf+ATws6XFJtxYY/xLgF5LurXYd\n75E0VGCeUz4KfKvJASPiIPBl4AXgJeBXEfH9sz3GJ/RPI2kE2ATcVm0ZGxURJyPiSmAp8B5J1zU1\ntqQPA/uqLXvJy+itioir6Gx5Pynp3Q2PvwC4Cvinap6jwO0NzwGApPOBG4EHGh73UjpvEZYBfwCM\nSDrrxZzONYgvARefdn9p9be+U+1CbALuj4gHS85V7Wp9G1jZ4LCrgBslPUvnf/j3SbqvwfEBiIiX\nq98HgM103p406UVgb0Q8Ud3fRCeYJXwI2FatS5NWAlsj4pcRcQIYA951tgecaxAfB/5Q0rLqqNDH\ngBJH63pxodSvA7sj4u4Sg0t6o6TR6vYQ8AE6B7caERF3RMTFEXEpndfh0Yi4uanxASQNV3sNSFoE\nfBD4aZNzRMQ+YK+k5dWfVgNN78KfchMN75ZWngaukTSozvXNV9M57jCjrif0zyZ6cLK/ulDqe4Hf\nk/QC8PlTb+QbnGMV8AlgvHoPF8AdEfHdBqd5E/CN6oUZoLPlfaTB8XvhImBz9XHGBcDGiNhSYJ51\nwMZq1/FZoPGL40oapnOg5i+bHjsidlV7I9uAE8AO4J6z1lMdXjWz15EP1pgl4CCaJeAgmiXgIJol\n4CCaJeAgmiXgIJol4CCaJfB/quNiKOmyu7oAAAAASUVORK5CYII=\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": 54, + "metadata": { + "collapsed": false, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Returning path because at (1, 7) while goal is (1, 7)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOIAAAEACAYAAACu66rqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nOIhmCTiIZgn8H80GWbfKzOFHAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Returning path because at (1, 9) while goal is (1, 9)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAU8AAAD7CAYAAADq4RYlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAD4ZJREFUeJzt3W+MXPV1xvHnIU6YwVusVNo1aqwYSEu8oKSA0oYGRVXj\nItxEghCpEiFVYirlRZXKKImSAH0RXkXEIUrpXwmFEKigkeIYGVWhUGIpUoiaFoiNy+66UYOCIWW9\nUQjWOmsHh9MXM3bX6921Ofd3d37Dfj+SpZnx3XPPndl55t6Zu3McEQIAvDZnDboBABhGhCcAJBCe\nAJBAeAJAAuEJAAmEJwAkrGl7BbY5FwrA0IoIL3Z76+EpSV//0DtWYjVpD05M67qL1w+6jSXV3p9U\nf4+19yfV32Pt/Unle9y6c9+S/8dhOwAkEJ4AkEB4Sto0unbQLSyr9v6k+nusvT+p/h5r709a2R7d\n9t+2247a3/MEgMVs3blvyQ+M2PMEgATCEwASCE8ASCA8ASCB8ASABMITABIITwBIIDwBIIHwBICE\n04an7bttT9t+et5tb7b9qO39th+xva7dNgGgLmey53mPpKsX3HazpMci4u2Sdku6pXRjAFCz04Zn\nRHxP0ksLbr5W0r39y/dK+mDhvgCgatn3PMciYlqSIuJFSWPlWgKA+pX6wIhRGwBWlewYjmnb6yNi\n2vZ5kg4ut/CDE9MnLm8aXavx0ZHkaqVtj0zq0OFj6Z9fzLlr1+hvrh4vVm/ibVt0ztpy3ys4Ozur\nO+64o1i9sXVrtH1zue2VpM9+51kdfHm2WL2xdSPavvmCYvVK9ydJ3W5Hc3NHqq23Gu/Dpts8OTOr\nqZnDZ7TsmYan+/+Oe0jSVklflPQxSbuW++GSM0UOHT4m3VasXK/mbWXDuGRwStLIyIhKfu2qXXZ7\nJengy7Mq+d2w9qJfoZhWuj+p12PpbeY+bF6vifHRkZN27nZNLb1feCanKj0g6fuSLrL9nO0bJd0u\n6Srb+yVt7l8HgFXjtHueEXHDEv/1x4V7AYChwV8YAUAC4QkACYQnACQQngCQQHgCQALhCQAJhCcA\nJBCeAJBAeAJAAuEJAAmEJwAkEJ4AkEB4AkAC4QkACYQnACQQngCQkJ1hNDB+oxS3la9Z0i8PHy4+\nw6jkRIVOR9q6c1+5gpI6nU7RsQ+dTqdoj6X7a6Mm92Fz3W6nWK3TGbrwjFdUdJ6PpKLBJEkX/8+/\nFq23dee+wjOM2rgPj1Q/z6eN+Ttf/9A7itXrPc71bnNb92FNM4xeCw7bASCB8ASABMITABIITwBI\nIDwBIIHwBIAEwhMAEghPAEggPAEggfAEgATCEwASCE8ASCA8ASCB8ASAhEbhafsW28/Yftr2/bbf\nVKoxAKhZOjxtb5T0cUmXRcQ71ftu0OtLNQYANWvyZciHJP1K0lrbr0o6R9JPi3QFAJVL73lGxEuS\nvizpOUkvSPpFRDxWqjEAqFl6z9P2hZI+KWmjpJcl7bB9Q0Q8sHDZByemT1zeNLpW46Mj2dWq2y0/\nNqPbLVvvs995Vgdfni1Wr/Q2dzrl78NO5+zq5/mUHtFQel5Ot1v3Nq+GGUaTM7Oamjl8Rss2OWx/\nl6THI+LnkmR7p6T3SDolPK+7eH2D1Zxsbq7+GUYHX54tPpel/KycYuUkSfbRVTXP53jNkubm6p8D\nVfIxltp5nJsYHx05aedu19TBJZdt8mn7fklX2O641/FmSZMN6gHA0GjynudeSfdJelLSXkmWdFeh\nvgCgao1GD0fElyR9qVAvADA0+AsjAEggPAEggfAEgATCEwASCE8ASCA8ASCB8ASABMITABIITwBI\nIDwBIIHwBIAEwhMAEghPAEggPAEggfAEgATCEwASGn0Z8iC0MQCu0+nNUilXr66hVqfWq3+IXu3D\n0I7XrPn3po3fw5LbK9X/XFnO0IVnWwPgah+8VdIwDNGrfRhaGzVrH9hWelibVP9zZTkctgNAAuEJ\nAAmEJwAkEJ4AkEB4AkAC4QkACYQnACQQngCQQHgCQALhCQAJhCcAJBCeAJBAeAJAAuEJAAmNwtP2\nOtvftD1p+xnb7y7VGADUrOn3ed4p6dsR8ae210g6p0BPAFC9dHjaPlfSeyNiqyRFxDFJhwr1BQBV\na3LYfoGkn9m+x/ZTtu+yXXgYAwDUqclh+xpJl0v6REQ8YfuvJd0s6fMLF3xwYvrE5U2jazU+OpJe\naTszjM6ufnZMScMxB6rux6SNmm3Uq3nGUhs1mz5XJmdmNTVz+IyWbRKez0s6EBFP9K/vkPS5xRa8\n7uL1DVZzsnbm7xytetbLsMwwKlnTPlq43pEWtrnuOUu112ujZtPnyvjoyEk7d7umDi65bPqwPSKm\nJR2wfVH/ps2SJrL1AGCYNP20fZuk+22/UdKPJd3YvCUAqF+j8IyIvZJ+r1AvADA0+AsjAEggPAEg\ngfAEgATCEwASCE8ASCA8ASCB8ASABMITABIITwBIIDwBIIHwBIAEwhMAEghPAEggPAEggfAEgISm\nX4a84tqYv9MtPLau261rLstCY+vWyD5WtGanU/Zxqb1er2bdc5Zqr9dGzdLPleUMXXi2NX+npLm5\n8rNtStq+ebxoPamduU3l50oVKyfp+Jyl2reZGUZt4bAdABIITwBIIDwBIIHwBIAEwhMAEghPAEgg\nPAEggfAEgATCEwASCE8ASCA8ASCB8ASABMITABIITwBIaByets+y/ZTth0o0BADDoMSe502SJgrU\nAYCh0Sg8bW+Q9H5JXy3TDgAMh6Z7nl+R9BlJhb+jGwDqlg5P2x+QNB0ReyS5/w8AVgVn54fY/oKk\nP5N0TFJX0m9I2hkRH12wXFy7aezE9U2jazU+OpJu+C8e3qe5ufSPL6rTkY4cKVnvbB05crTaet2u\nit+H3W5Hc3Pl7sTS9Uo/xr2apR+X0tvc0ZGCG126Xhs1u92O/vFPfif985Mzs5qaOXzi+q6pg4qI\nRXcM0wPgIuJWSbdKku0/lPTphcF53HUXr8+u5hRtDYArWbM3GKzmem3ch0eqHtjWzjYfXVUD20oP\nqJPa2eYmxkdHTtq52zV1cMllOc8TABKKjB6OiO9K+m6JWgAwDNjzBIAEwhMAEghPAEggPAEggfAE\ngATCEwASCE8ASCA8ASCB8ASABMITABIITwBIIDwBIIHwBIAEwhMAEghPAEggPAEgociXIa+ksXVr\nZB8rWrPb7Y1pWC31Op2y9Y7X3LpzX9F6tW9zt1t6mzuNx0i0Xa/k9h6vWbLHbrdTrNbpDF14bt88\nPugWhl7p+UBSG3Ogytcbhvk7q6leGzVLBvHpcNgOAAmEJwAkEJ4AkEB4AkAC4QkACYQnACQQngCQ\nQHgCQALhCQAJhCcAJBCeAJBAeAJAAuEJAAmEJwAkpMPT9gbbu20/Y3uf7W0lGwOAmjX5Ps9jkj4V\nEXtsj0h60vajETFVqDcAqFZ6zzMiXoyIPf3Ls5ImJb2lVGMAULMi73naPl/SpZJ+UKIeANSu8RiO\n/iH7Dkk39fdAT/HgxPSJy5tG12p8dKTpatHAap0DVfv8ndrrdbtl67VRc2xds2yZnJnV1MzhM1rW\nTeaH2F4j6V8kPRwRdy6xTJSeHQO8VqXnDUn1zwiyXXxu02rT/71ZNN2bHrZ/TdLEUsEJAK9XTU5V\nulLSRyS9z/YPbT9le0u51gCgXun3PCPicUlvKNgLAAwN/sIIABIITwBIIDwBIIHwBIAEwhMAEghP\nAEggPAEggfAEgATCEwASCE8ASCA8ASCB8ASABMITABIITwBIIDwBIIHwBICExgPggGEwtm6k+uFl\ntQ1Dw/IIT6wK2zdfMOgW8DrDYTsAJBCeAJBAeAJAAuEJAAmEJwAkEJ4AkEB4AkAC4QkACYQnACQQ\nngCQQHgCQALhCQAJhCcAJDQKT9tbbE/Z/m/bnyvVFADULh2ets+S9HeSrpZ0iaQP295UqrGVNDkz\nO+gWllV7f1L9Pdben1R/j7X3J61sj032PH9f0o8i4icR8Yqkb0i6tkxbK2tq5vCgW1hW7f1J9fdY\ne39S/T3W3p+0sj02Cc+3SDow7/rz/dsA4HWPD4wAIMERkftB+wpJt0XElv71myVFRHxxwXK5FQBA\nBSJi0cFSTcLzDZL2S9os6X8l/YekD0fEZLZJABgW6QFwEfFr238p6VH1Dv/vJjgBrBbpPU8AWM1a\n+8Co9hPobW+wvdv2M7b32d426J4WY/ss20/ZfmjQvSzG9jrb37Q92b8v3z3onhayfUu/t6dt32/7\nTRX0dLftadtPz7vtzbYftb3f9iO211XW3/b+47zH9rdsnzuo/pbqcd7/fdr2q7Z/s631txKeQ3IC\n/TFJn4qISyT9gaRPVNijJN0kaWLQTSzjTknfjohxSb8rqaq3bmxvlPRxSZdFxDvVe6vq+sF2JUm6\nR73nx3w3S3osIt4uabekW1a8q/+3WH+PSrokIi6V9CMNtj9p8R5le4OkqyT9pM2Vt7XnWf0J9BHx\nYkTs6V+eVe9JX9V5qv1fgvdL+uqge1lMf8/jvRFxjyRFxLGIODTgthY6JOlXktbaXiPpHEk/HWxL\nUkR8T9JLC26+VtK9/cv3SvrgijY1z2L9RcRjEfFq/+q/S9qw4o2d3M9i96EkfUXSZ9pef1vhOVQn\n0Ns+X9Klkn4w2E5OcfyXoNY3pi+Q9DPb9/TfWrjLdnfQTc0XES9J+rKk5yS9IOkXEfHYYLta0lhE\nTEu9F3dJYwPuZzl/LunhQTexkO1rJB2IiH1tr2vVnyRve0TSDkk39fdAq2D7A5Km+3vH7v+rzRpJ\nl0v6+4i4XNIv1Tv0rIbtCyV9UtJGSb8lacT2DYPt6oxV+aJp+68kvRIRDwy6l/n6L9y3Svr8/Jvb\nWl9b4fmCpLfOu76hf1tV+odxOyT9U0TsGnQ/C1wp6RrbP5b0z5L+yPZ9A+5poefVe5V/on99h3ph\nWpN3SXo8In4eEb+WtFPSewbc01Kmba+XJNvnSTo44H5OYXurem8l1fgC9DZJ50vaa/tZ9XLnSdut\n7MG3FZ7/Kem3bW/sf7J5vaQaPy3+mqSJiLhz0I0sFBG3RsRbI+JC9e6/3RHx0UH3NV//EPOA7Yv6\nN21WfR9u7Zd0he2ObavXYy0fai08onhI0tb+5Y9JGvQL+kn92d6i3ttI10TE0YF1dbITPUbEf0XE\neRFxYURcoN6L+2UR0cqLUCvh2X+FP34C/TOSvlHbCfS2r5T0EUnvs/3D/nt2Wwbd1xDaJul+23vU\n+7T9CwPu5yQRsVfSfZKelLRXvSfaXQNtSpLtByR9X9JFtp+zfaOk2yVdZfv4X+7dXll/fytpRNK/\n9Z8v/zCo/pbpcb5Qi4ftnCQPAAmr/gMjAMggPAEggfAEgATCEwASCE8ASCA8ASCB8ASABMITABL+\nD8ZDib3sS3M7AAAAAElFTkSuQmCC\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": [ + "m1 = maze1()\n", + "m1.draw_path(heuristic(m1))\n", + "m1.draw()\n", + "\n", + "m2 = maze2()\n", + "m2.draw_path(heuristic(m2))\n", + "m2.draw()\n", + "\n", + "m3 = mazeUnsolvable1()\n", + "m3.draw_path(heuristic(m3))\n", + "m3.draw()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You also have to be able to handle switch and door puzzles:" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "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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\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": 55, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Returning path because at (1, 9) while goal is (1, 9)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAU8AAAD7CAYAAADq4RYlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Returning path because at (6, 1) while goal is (6, 1)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOIAAAEACAYAAACu66rqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "m4 = maze3()\n", + "m4.draw_path(heuristic(m4))\n", + "m4.draw()\n", + "\n", + "m5 = maze4()\n", + "m5.draw_path(heuristic(m5))\n", + "m5.draw()\n", + "\n", + "\n", + "\n" + ] + }, + { + "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": 8, + "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": 9, + "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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\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": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{<__main__.Maze object at 0x1038200b8>: 'a'}\n" + ] + } + ], + "source": [ + "a = {maze1() : \"a\"}\n", + "print(a)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "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": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/projects/4-project-ideas/README.md b/projects/4-project-ideas/README.md index b31b0f9..1248fc9 100644 --- a/projects/4-project-ideas/README.md +++ b/projects/4-project-ideas/README.md @@ -1 +1,16 @@ -Give a list of three or more project ideas you might be interested in doing, either from the suggestions or your own idea. If you have a partner or partners in mind, let me know as well. Submit them (as Markdown `.md` files) in this folder. +# Project Idea +Create a (convolutional) neural network to parse images with handwritten content into a textual output. + +Outline: + * Will likely not use a framework (external library) for the network + * May use a mathematical algebra (matrix) library + * Will train on a large open-source dataset + * May need to run on external server + +# Group Members + * Valerio Galanti (valerio@galanti.net) + * Neil Johari (@cskreem) + * William Chern (@wchern) + + + tl;dr OCR diff --git a/projects/6-perceptron/Perceptrons.ipynb b/projects/6-perceptron/Perceptrons.ipynb index c2e9823..402cde0 100644 --- a/projects/6-perceptron/Perceptrons.ipynb +++ b/projects/6-perceptron/Perceptrons.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": { "collapsed": false }, @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { "collapsed": true }, @@ -31,7 +31,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "collapsed": false }, @@ -63,11 +63,42 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": { "collapsed": false }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAEACAYAAABWLgY0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEACAYAAABCl1qQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nZFhIkpoMC0lS0/8DzSrgeX9nXMkAAAAASUVORK5CYII=\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", @@ -167,7 +198,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.1" + "version": "3.5.2" } }, "nbformat": 4, diff --git a/projects/6-perceptron/neil.ipynb b/projects/6-perceptron/neil.ipynb new file mode 100644 index 0000000..58d0e30 --- /dev/null +++ b/projects/6-perceptron/neil.ipynb @@ -0,0 +1,8144 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "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": 5, + "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": 52, + "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", + " #print(\"i \" + str(i))\n", + " # in each epoch, pick a subset of the training set (just one for now)\n", + " (example,actual) = choice(training)\n", + " \n", + " activation = np.dot(weights, example)\n", + " \n", + " \n", + " predicted = 1 if activation >= 0 else 0\n", + " error = actual - predicted\n", + " errors.append(error)\n", + " \n", + " \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", + " \n", + " # update each weight according to the perceptron update rule\n", + " for i in range(0, len(weights)): \n", + " weights[i] += example[i]*error\n", + " return (errors,weights)" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "example (0, 0, 1), actual 0\n", + "activation 0.0039639357737\n", + "predicted 1, error -1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by -1\n", + "example (1, 1, 1), actual 1\n", + "activation -0.961181710717\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1\n", + "Updating weight 1 by 1\n", + "Updating weight 2 by 1\n", + "example (0, 1, 1), actual 0\n", + "activation 1.02255838865\n", + "predicted 1, error -1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by -1\n", + "Updating weight 2 by -1\n", + "example (1, 0, 1), actual 0\n", + "activation 0.0202238364023\n", + "predicted 1, error -1\n", + "Updating weight 0 by -1\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by -1\n", + "example (0, 1, 1), actual 0\n", + "activation -1.97744161135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -1.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation -1.96118171072\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1\n", + "Updating weight 1 by 1\n", + "Updating weight 2 by 1\n", + "example (0, 0, 1), actual 0\n", + "activation -0.996036064226\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 0\n", + "activation 0.0202238364023\n", + "predicted 1, error -1\n", + "Updating weight 0 by -1\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by -1\n", + "example (0, 0, 1), actual 0\n", + "activation -1.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 0\n", + "activation -1.9797761636\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation -0.977441611346\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation -0.961181710717\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1\n", + "Updating weight 1 by 1\n", + "Updating weight 2 by 1\n", + "example (0, 0, 1), actual 0\n", + "activation -0.996036064226\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 2.03881828928\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 2.03881828928\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 2.03881828928\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.996036064226\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 0\n", + "activation 0.0202238364023\n", + "predicted 1, error -1\n", + "Updating weight 0 by -1\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by -1\n", + "example (1, 0, 1), actual 0\n", + "activation -1.9797761636\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -1.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 0.0388182892829\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation 0.0225583886543\n", + "predicted 1, error -1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by -1\n", + "Updating weight 2 by -1\n", + "example (0, 0, 1), actual 0\n", + "activation -2.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 0\n", + "activation -2.9797761636\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 0\n", + "activation -2.9797761636\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation -1.96118171072\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1\n", + "Updating weight 1 by 1\n", + "Updating weight 2 by 1\n", + "example (0, 0, 1), actual 0\n", + "activation -1.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.03881828928\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation 0.0225583886543\n", + "predicted 1, error -1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by -1\n", + "Updating weight 2 by -1\n", + "example (0, 1, 1), actual 0\n", + "activation -1.97744161135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation -1.97744161135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation -1.97744161135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation -1.97744161135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -2.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation -0.961181710717\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1\n", + "Updating weight 1 by 1\n", + "Updating weight 2 by 1\n", + "example (0, 0, 1), actual 0\n", + "activation -1.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 2.03881828928\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -1.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -1.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation 0.0225583886543\n", + "predicted 1, error -1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by -1\n", + "Updating weight 2 by -1\n", + "example (1, 0, 1), actual 0\n", + "activation -0.979776163598\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation -1.97744161135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -2.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 0.0388182892829\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation -1.97744161135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -2.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -2.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -2.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 0\n", + "activation -0.979776163598\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -2.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -2.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -2.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation -1.97744161135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 0.0388182892829\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation -1.97744161135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 0.0388182892829\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 0.0388182892829\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 0.0388182892829\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 0.0388182892829\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -2.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation -1.97744161135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 0\n", + "activation -0.979776163598\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation -1.97744161135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 0\n", + "activation -0.979776163598\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -2.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 0.0388182892829\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 0\n", + "activation -0.979776163598\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation -1.97744161135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 0.0388182892829\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -2.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -2.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 0.0388182892829\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 0\n", + "activation -0.979776163598\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -2.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 0\n", + "activation -0.979776163598\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 0\n", + "activation -0.979776163598\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation -1.97744161135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -2.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -2.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 0.0388182892829\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -2.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation -1.97744161135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -2.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation -1.97744161135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -2.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 0.0388182892829\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 0\n", + "activation -0.979776163598\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation -1.97744161135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation -1.97744161135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation -1.97744161135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 0\n", + "activation -0.979776163598\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 0.0388182892829\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 0.0388182892829\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 0.0388182892829\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation -1.97744161135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -2.99603606423\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 0.0388182892829\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation -1.97744161135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 0\n", + "activation -1.97744161135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAEACAYAAABWLgY0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAEACAYAAABRQBpkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\neXn4hSP9BU8AAAAASUVORK5CYII=\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": 54, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "example (1, 1, 1), actual 1\n", + "activation 0.0140786194345\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation 0.0122660713034\n", + "predicted 1, error -1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by -1\n", + "example (1, 1, 1), actual 1\n", + "activation -0.985921380566\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1\n", + "Updating weight 1 by 1\n", + "Updating weight 2 by 1\n", + "example (1, 1, 1), actual 1\n", + "activation 2.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation 0.0122660713034\n", + "predicted 1, error -1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by -1\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0136086235182\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0136086235182\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0136086235182\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0136086235182\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0136086235182\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0136086235182\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0136086235182\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0136086235182\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0136086235182\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0136086235182\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0136086235182\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0136086235182\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0136086235182\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0136086235182\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0136086235182\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0136086235182\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0136086235182\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0136086235182\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.987733928697\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0136086235182\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0136086235182\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 1\n", + "activation 1.01407861943\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0127360672196\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAEACAYAAABWLgY0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nM/KS1DAjL0kNM/KS1LD/A0QsjLVmYaJMAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAEACAYAAABRQBpkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nx11rAAAAAElFTkSuQmCC\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": 55, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "example (1, 0, 1), actual 1\n", + "activation 0.0503163607377\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 0\n", + "activation 0.0967053039322\n", + "predicted 1, error -1\n", + "Updating weight 0 by -1\n", + "Updating weight 1 by -1\n", + "Updating weight 2 by -1\n", + "example (1, 1, 1), actual 0\n", + "activation -2.90329469607\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation -1.94968363926\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 1\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0503163607377\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 0\n", + "activation -0.903294696068\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0503163607377\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 0\n", + "activation -0.903294696068\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0503163607377\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 0\n", + "activation -0.903294696068\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 0\n", + "activation -0.903294696068\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation -0.921553133047\n", + "predicted 0, error 1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 1\n", + "Updating weight 2 by 1\n", + "example (1, 1, 1), actual 0\n", + "activation 1.09670530393\n", + "predicted 1, error -1\n", + "Updating weight 0 by -1\n", + "Updating weight 1 by -1\n", + "Updating weight 2 by -1\n", + "example (1, 0, 1), actual 1\n", + "activation -0.949683639262\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 1\n", + "example (1, 0, 1), actual 1\n", + "activation 1.05031636074\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation 1.03205792376\n", + "predicted 1, error -1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by -1\n", + "example (0, 1, 1), actual 1\n", + "activation -0.921553133047\n", + "predicted 0, error 1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 1\n", + "Updating weight 2 by 1\n", + "example (1, 1, 1), actual 0\n", + "activation 1.09670530393\n", + "predicted 1, error -1\n", + "Updating weight 0 by -1\n", + "Updating weight 1 by -1\n", + "Updating weight 2 by -1\n", + "example (0, 1, 1), actual 1\n", + "activation -0.921553133047\n", + "predicted 0, error 1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 1\n", + "Updating weight 2 by 1\n", + "example (1, 1, 1), actual 0\n", + "activation 0.0967053039322\n", + "predicted 1, error -1\n", + "Updating weight 0 by -1\n", + "Updating weight 1 by -1\n", + "Updating weight 2 by -1\n", + "example (0, 1, 1), actual 1\n", + "activation -0.921553133047\n", + "predicted 0, error 1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 1\n", + "Updating weight 2 by 1\n", + "example (0, 0, 1), actual 0\n", + "activation 1.03205792376\n", + "predicted 1, error -1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by -1\n", + "example (1, 0, 1), actual 1\n", + "activation -1.94968363926\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 1\n", + "example (0, 0, 1), actual 0\n", + "activation 1.03205792376\n", + "predicted 1, error -1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by -1\n", + "example (1, 0, 1), actual 1\n", + "activation -0.949683639262\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 1\n", + "example (0, 1, 1), actual 1\n", + "activation 1.07844686695\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 0\n", + "activation 1.09670530393\n", + "predicted 1, error -1\n", + "Updating weight 0 by -1\n", + "Updating weight 1 by -1\n", + "Updating weight 2 by -1\n", + "example (1, 0, 1), actual 1\n", + "activation -0.949683639262\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 1\n", + "example (1, 0, 1), actual 1\n", + "activation 1.05031636074\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 1.05031636074\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 1.05031636074\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 0\n", + "activation 0.0967053039322\n", + "predicted 1, error -1\n", + "Updating weight 0 by -1\n", + "Updating weight 1 by -1\n", + "Updating weight 2 by -1\n", + "example (0, 0, 1), actual 0\n", + "activation 0.0320579237584\n", + "predicted 1, error -1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by -1\n", + "example (0, 1, 1), actual 1\n", + "activation -2.92155313305\n", + "predicted 0, error 1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 1\n", + "Updating weight 2 by 1\n", + "example (0, 1, 1), actual 1\n", + "activation -0.921553133047\n", + "predicted 0, error 1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 1\n", + "Updating weight 2 by 1\n", + "example (1, 1, 1), actual 0\n", + "activation 0.0967053039322\n", + "predicted 1, error -1\n", + "Updating weight 0 by -1\n", + "Updating weight 1 by -1\n", + "Updating weight 2 by -1\n", + "example (0, 1, 1), actual 1\n", + "activation -0.921553133047\n", + "predicted 0, error 1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 1\n", + "Updating weight 2 by 1\n", + "example (0, 1, 1), actual 1\n", + "activation 1.07844686695\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation -0.949683639262\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 1\n", + "example (0, 1, 1), actual 1\n", + "activation 2.07844686695\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation 2.03205792376\n", + "predicted 1, error -1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by -1\n", + "example (0, 0, 1), actual 0\n", + "activation 1.03205792376\n", + "predicted 1, error -1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by -1\n", + "example (1, 1, 1), actual 0\n", + "activation -0.903294696068\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0784468669528\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation -0.949683639262\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 1\n", + "example (0, 1, 1), actual 1\n", + "activation 1.07844686695\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation 1.05031636074\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 0\n", + "activation 1.09670530393\n", + "predicted 1, error -1\n", + "Updating weight 0 by -1\n", + "Updating weight 1 by -1\n", + "Updating weight 2 by -1\n", + "example (0, 0, 1), actual 0\n", + "activation 0.0320579237584\n", + "predicted 1, error -1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by -1\n", + "example (0, 1, 1), actual 1\n", + "activation -1.92155313305\n", + "predicted 0, error 1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 1\n", + "Updating weight 2 by 1\n", + "example (0, 0, 1), actual 0\n", + "activation 0.0320579237584\n", + "predicted 1, error -1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by -1\n", + "example (1, 0, 1), actual 1\n", + "activation -1.94968363926\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 1\n", + "example (1, 1, 1), actual 0\n", + "activation 0.0967053039322\n", + "predicted 1, error -1\n", + "Updating weight 0 by -1\n", + "Updating weight 1 by -1\n", + "Updating weight 2 by -1\n", + "example (0, 1, 1), actual 1\n", + "activation -1.92155313305\n", + "predicted 0, error 1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 1\n", + "Updating weight 2 by 1\n", + "example (0, 0, 1), actual 0\n", + "activation 0.0320579237584\n", + "predicted 1, error -1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by -1\n", + "example (0, 1, 1), actual 1\n", + "activation -0.921553133047\n", + "predicted 0, error 1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 1\n", + "Updating weight 2 by 1\n", + "example (1, 0, 1), actual 1\n", + "activation -0.949683639262\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 1\n", + "example (0, 0, 1), actual 0\n", + "activation 1.03205792376\n", + "predicted 1, error -1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by -1\n", + "example (1, 0, 1), actual 1\n", + "activation 0.0503163607377\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation 0.0320579237584\n", + "predicted 1, error -1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by -1\n", + "example (1, 1, 1), actual 0\n", + "activation 0.0967053039322\n", + "predicted 1, error -1\n", + "Updating weight 0 by -1\n", + "Updating weight 1 by -1\n", + "Updating weight 2 by -1\n", + "example (0, 1, 1), actual 1\n", + "activation -1.92155313305\n", + "predicted 0, error 1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 1\n", + "Updating weight 2 by 1\n", + "example (0, 0, 1), actual 0\n", + "activation -0.967942076242\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 0\n", + "activation -0.903294696068\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 0\n", + "activation -0.903294696068\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 0\n", + "activation -0.903294696068\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 0\n", + "activation -0.903294696068\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.967942076242\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation -1.94968363926\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 1\n", + "example (1, 1, 1), actual 0\n", + "activation 1.09670530393\n", + "predicted 1, error -1\n", + "Updating weight 0 by -1\n", + "Updating weight 1 by -1\n", + "Updating weight 2 by -1\n", + "example (0, 1, 1), actual 1\n", + "activation -0.921553133047\n", + "predicted 0, error 1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 1\n", + "Updating weight 2 by 1\n", + "example (0, 1, 1), actual 1\n", + "activation 1.07844686695\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 1.07844686695\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 1.07844686695\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation -0.949683639262\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 1\n", + "example (0, 0, 1), actual 0\n", + "activation 1.03205792376\n", + "predicted 1, error -1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by -1\n", + "example (0, 1, 1), actual 1\n", + "activation 1.07844686695\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation 0.0320579237584\n", + "predicted 1, error -1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by -1\n", + "example (1, 1, 1), actual 0\n", + "activation 0.0967053039322\n", + "predicted 1, error -1\n", + "Updating weight 0 by -1\n", + "Updating weight 1 by -1\n", + "Updating weight 2 by -1\n", + "example (1, 1, 1), actual 0\n", + "activation -2.90329469607\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -1.96794207624\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -1.96794207624\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation -1.92155313305\n", + "predicted 0, error 1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 1\n", + "Updating weight 2 by 1\n", + "example (1, 1, 1), actual 0\n", + "activation -0.903294696068\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0784468669528\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.967942076242\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 0\n", + "activation -0.903294696068\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0784468669528\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.967942076242\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0784468669528\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 0\n", + "activation -0.903294696068\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 0\n", + "activation -0.903294696068\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0784468669528\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 1, 1), actual 0\n", + "activation -0.903294696068\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.967942076242\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.967942076242\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 1, 1), actual 1\n", + "activation 0.0784468669528\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (0, 0, 1), actual 0\n", + "activation -0.967942076242\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 0\n", + "example (1, 0, 1), actual 1\n", + "activation -1.94968363926\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by 1\n", + "example (0, 0, 1), actual 0\n", + "activation 0.0320579237584\n", + "predicted 1, error -1\n", + "Updating weight 0 by 0\n", + "Updating weight 1 by 0\n", + "Updating weight 2 by -1\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAEACAYAAABWLgY0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nrkJggg==\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": [ + "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": 56, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "example (8.192802215060135, 3.9361834633946446, 1), actual 0\n", + "activation 0.257125827138\n", + "predicted 1, error -1\n", + "Updating weight 0 by -8.192802215060135\n", + "Updating weight 1 by -3.9361834633946446\n", + "Updating weight 2 by -1\n", + "example (9.518311571730163, 6.768531398973953, 1), actual 0\n", + "activation -105.306788068\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.8196945752536577, 5.205272887963199, 1), actual 1\n", + "activation -28.0945259766\n", + "predicted 0, error 1\n", + "Updating weight 0 by 0.8196945752536577\n", + "Updating weight 1 by 5.205272887963199\n", + "Updating weight 2 by 1\n", + "example (3.631450050859798, 1.9500588767296667, 1), actual 0\n", + "activation -24.1644752055\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.7152810487220673, 5.142636385860659, 1), actual 1\n", + "activation 1.35963486557\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.8295593621772364, 6.46588813346654, 1), actual 1\n", + "activation -12.4892021699\n", + "predicted 0, error 1\n", + "Updating weight 0 by 2.8295593621772364\n", + "Updating weight 1 by 6.46588813346654\n", + "Updating weight 2 by 1\n", + "example (7.448079300022808, 3.103095683918884, 1), actual 0\n", + "activation -8.60657805333\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.18767455738911, 9.398469126153845, 1), actual 1\n", + "activation 50.3777097268\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.448079300022808, 3.103095683918884, 1), actual 0\n", + "activation -8.60657805333\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.741906198125639, 7.276494136007247, 1), actual 0\n", + "activation 17.8698806713\n", + "predicted 1, error -1\n", + "Updating weight 0 by -8.741906198125639\n", + "Updating weight 1 by -7.276494136007247\n", + "Updating weight 2 by -1\n", + "example (8.741906198125639, 7.276494136007247, 1), actual 0\n", + "activation -112.498410217\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.641925533937323, 6.090415031406695, 1), actual 0\n", + "activation -124.992684698\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.710739229023136, 0.9315734142648702, 1), actual 0\n", + "activation -88.536197507\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.15663629270499, 2.2715570393710327, 1), actual 0\n", + "activation -120.348626438\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.365921435638924, 1.7665655545978187, 1), actual 0\n", + "activation -57.0434775276\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.293153051265162, 3.6596267906380984, 1), actual 0\n", + "activation -81.7169041085\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.710739229023136, 0.9315734142648702, 1), actual 0\n", + "activation -88.536197507\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.764445713683653, 1.424649425018134, 1), actual 0\n", + "activation -128.807928565\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.5448938985282936, 7.797834020938884, 1), actual 1\n", + "activation -3.53166578049\n", + "predicted 0, error 1\n", + "Updating weight 0 by 0.5448938985282936\n", + "Updating weight 1 by 7.797834020938884\n", + "Updating weight 2 by 1\n", + "example (4.450406859792585, 1.4683907453208889, 1), actual 0\n", + "activation -43.4287607713\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.9935925736468505, 5.270584030180434, 1), actual 0\n", + "activation -57.059872312\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.710739229023136, 0.9315734142648702, 1), actual 0\n", + "activation -76.6153017838\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.1647757502712945, 5.65257882633725, 1), actual 1\n", + "activation 7.514550848\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9168198401195615, 2.3879060556407095, 1), actual 1\n", + "activation 9.11581139709\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.401406238607672, 8.470493640496457, 1), actual 1\n", + "activation 40.5200404122\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.907198863790789, 8.325278744588815, 1), actual 0\n", + "activation -30.7071309499\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.05745539735547811, 9.527934518916851, 1), actual 1\n", + "activation 79.074226332\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.7200789393907734, 5.496880819540703, 1), actual 1\n", + "activation 24.6020530833\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.181485178079948, 7.2791630783924095, 1), actual 0\n", + "activation -42.8442015976\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.620754472047351, 6.259532682231028, 1), actual 0\n", + "activation -31.4232413007\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.7200789393907734, 5.496880819540703, 1), actual 1\n", + "activation 24.6020530833\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.727355694553044, 0.3776260800598663, 1), actual 0\n", + "activation -94.1249844853\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.9983266598478, 1.8640958741769331, 1), actual 0\n", + "activation -59.8449286716\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.741906198125639, 7.276494136007247, 1), actual 0\n", + "activation -49.994105341\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.270048303565226, 4.145168925603738, 1), actual 0\n", + "activation -57.1614018117\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.662901384102844, 5.365493436584224, 1), actual 0\n", + "activation -13.9130985932\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.620754472047351, 6.259532682231028, 1), actual 0\n", + "activation -31.4232413007\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.192802215060135, 3.9361834633946446, 1), actual 0\n", + "activation -70.6253869035\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.05745539735547811, 9.527934518916851, 1), actual 1\n", + "activation 79.074226332\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.641925533937323, 6.090415031406695, 1), actual 0\n", + "activation -71.2468127705\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3962070188044935, 5.021835204430203, 1), actual 1\n", + "activation 12.0752475812\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.917163743267875, 6.542643315036429, 1), actual 0\n", + "activation 5.30352276868\n", + "predicted 1, error -1\n", + "Updating weight 0 by -3.917163743267875\n", + "Updating weight 1 by -6.542643315036429\n", + "Updating weight 2 by -1\n", + "example (1.7200789393907734, 5.496880819540703, 1), actual 1\n", + "activation -19.0999083212\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1.7200789393907734\n", + "Updating weight 1 by 5.496880819540703\n", + "Updating weight 2 by 1\n", + "example (2.6768250252013868, 6.994872275079214, 1), actual 1\n", + "activation 11.6215486499\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.6104017774044366, 3.774113993604651, 1), actual 1\n", + "activation 4.26944678596\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.776368485745538, 3.82822551510246, 1), actual 0\n", + "activation -87.3101532452\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.910197726504086, 2.663137790168496, 1), actual 0\n", + "activation -8.22515193604\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.376558852812839, 3.8996371469160795, 1), actual 0\n", + "activation -50.9993591821\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.450406859792585, 1.4683907453208889, 1), actual 0\n", + "activation -54.7422700242\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.585454104080487, 9.497175946383228, 1), actual 1\n", + "activation 45.970579847\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.0930283200245614, 2.025801906750686, 1), actual 0\n", + "activation -15.5547305703\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.1647757502712945, 5.65257882633725, 1), actual 1\n", + "activation -5.34998480002\n", + "predicted 0, error 1\n", + "Updating weight 0 by 3.1647757502712945\n", + "Updating weight 1 by 5.65257882633725\n", + "Updating weight 2 by 1\n", + "example (0.5448938985282936, 7.797834020938884, 1), actual 1\n", + "activation 96.0219370035\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.641925533937323, 6.090415031406695, 1), actual 0\n", + "activation -32.8589852972\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.620754472047351, 6.259532682231028, 1), actual 0\n", + "activation 4.82012024413\n", + "predicted 1, error -1\n", + "Updating weight 0 by -6.620754472047351\n", + "Updating weight 1 by -6.259532682231028\n", + "Updating weight 2 by -1\n", + "example (0.7152810487220673, 5.142636385860659, 1), actual 1\n", + "activation 21.910322092\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.596006325563363, 0.20601525116155095, 1), actual 0\n", + "activation -82.0389737044\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.9983266598478, 1.8640958741769331, 1), actual 0\n", + "activation -96.8346720591\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.4355430271620131, 4.417792135688179, 1), actual 1\n", + "activation 22.2551024829\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.4256695234516705, 0.3391835724830805, 1), actual 0\n", + "activation -96.4005214031\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.68514293424815, 2.663703689110534, 1), actual 0\n", + "activation -49.0483251855\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.03580069578259, 8.4661693659913, 1), actual 1\n", + "activation 1.26185334321\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.776368485745538, 3.82822551510246, 1), actual 0\n", + "activation -116.508673502\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.4084822494885856, 3.341158023148373, 1), actual 0\n", + "activation -39.4845302804\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.61739680709439, 6.117839361458811, 1), actual 0\n", + "activation -24.9562124603\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.875266984278501, 4.490679281547934, 1), actual 0\n", + "activation -58.8284376025\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.7200789393907734, 5.496880819540703, 1), actual 1\n", + "activation 5.79355275767\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.8196945752536577, 5.205272887963199, 1), actual 1\n", + "activation 20.4063704478\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.293153051265162, 3.6596267906380984, 1), actual 0\n", + "activation -90.3745601287\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.9935925736468505, 5.270584030180434, 1), actual 0\n", + "activation -110.958939337\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.507374437231959, 2.8942089149396413, 1), actual 0\n", + "activation -99.3730714289\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.7200789393907734, 5.496880819540703, 1), actual 1\n", + "activation 5.79355275767\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.3987984768476194, 6.039436692979809, 1), actual 1\n", + "activation 33.6565873938\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.508752995382578, 5.336332860186444, 1), actual 0\n", + "activation -83.2448878396\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.860449470981059, 8.414673599175096, 1), actual 0\n", + "activation -32.6008223415\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.3279565582768065, 7.106134092027016, 1), actual 0\n", + "activation -49.845140239\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.492335903506584, 2.2501467996671174, 1), actual 0\n", + "activation -158.472312393\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3819906463580685, 6.783367960516962, 1), actual 1\n", + "activation 2.14256514441\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.7200789393907734, 5.496880819540703, 1), actual 1\n", + "activation 5.79355275767\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.585454104080487, 9.497175946383228, 1), actual 1\n", + "activation 34.7269366382\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.43628818342939, 6.982136553712499, 1), actual 0\n", + "activation -34.2837863032\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.181485178079948, 7.2791630783924095, 1), actual 0\n", + "activation -101.125048888\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.905682319649161, 7.02684831070679, 1), actual 1\n", + "activation -5.86807686251\n", + "predicted 0, error 1\n", + "Updating weight 0 by 2.905682319649161\n", + "Updating weight 1 by 7.02684831070679\n", + "Updating weight 2 by 1\n", + "example (2.905682319649161, 7.02684831070679, 1), actual 1\n", + "activation 52.9515100619\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.9983266598478, 1.8640958741769331, 1), actual 0\n", + "activation -65.3067213917\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.24631434468817104, 5.173384257803269, 1), actual 1\n", + "activation 68.7977580996\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.764445713683653, 1.424649425018134, 1), actual 0\n", + "activation -129.548562554\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.093258189224112, 5.108882558244428, 1), actual 0\n", + "activation -53.4437743788\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.68514293424815, 2.663703689110534, 1), actual 0\n", + "activation -18.623028748\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.722727452641504, 5.446057740436029, 1), actual 0\n", + "activation -27.6474697831\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3962070188044935, 5.021835204430203, 1), actual 1\n", + "activation 33.4799585186\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.0930283200245614, 2.025801906750686, 1), actual 0\n", + "activation -2.70108209664\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.1647757502712945, 5.65257882633725, 1), actual 1\n", + "activation 30.1974099537\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.764445713683653, 1.424649425018134, 1), actual 0\n", + "activation -129.548562554\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.5448938985282936, 7.797834020938884, 1), actual 1\n", + "activation 99.9810167676\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.764445713683653, 1.424649425018134, 1), actual 0\n", + "activation -129.548562554\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.860449470981059, 8.414673599175096, 1), actual 0\n", + "activation 41.6507347174\n", + "predicted 1, error -1\n", + "Updating weight 0 by -4.860449470981059\n", + "Updating weight 1 by -8.414673599175096\n", + "Updating weight 2 by -1\n", + "example (1.672673354327543, 3.946823625401171, 1), actual 1\n", + "activation -12.335615515\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1.672673354327543\n", + "Updating weight 1 by 3.946823625401171\n", + "Updating weight 2 by 1\n", + "example (5.376558852812839, 3.8996371469160795, 1), actual 0\n", + "activation -62.4850609048\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9168198401195615, 2.3879060556407095, 1), actual 1\n", + "activation 6.83845765085\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.61739680709439, 6.117839361458811, 1), actual 0\n", + "activation -9.32111690929\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.706875996441108, 9.923714046947334, 1), actual 0\n", + "activation -88.0002125431\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.496843709612131, 4.5641606813826066, 1), actual 0\n", + "activation -114.594449147\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.710739229023136, 0.9315734142648702, 1), actual 0\n", + "activation -114.600326656\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.2315888872941105, 1.9882133320366713, 1), actual 0\n", + "activation -114.623073399\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.270048303565226, 4.145168925603738, 1), actual 0\n", + "activation -95.5535903124\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.4084822494885856, 3.341158023148373, 1), actual 0\n", + "activation -30.8960241555\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.4355430271620131, 4.417792135688179, 1), actual 1\n", + "activation 34.4373612247\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.0511694684247652, 3.068483285849682, 1), actual 1\n", + "activation 10.5756127057\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.270048303565226, 4.145168925603738, 1), actual 0\n", + "activation -95.5535903124\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.15663629270499, 2.2715570393710327, 1), actual 0\n", + "activation -147.933412148\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.672673354327543, 3.946823625401171, 1), actual 1\n", + "activation 7.03963736532\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.9935925736468505, 5.270584030180434, 1), actual 0\n", + "activation -98.72646645\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.270048303565226, 4.145168925603738, 1), actual 0\n", + "activation -95.5535903124\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.376558852812839, 3.8996371469160795, 1), actual 0\n", + "activation -62.4850609048\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.722727452641504, 5.446057740436029, 1), actual 0\n", + "activation -73.4101887281\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.641925533937323, 6.090415031406695, 1), actual 0\n", + "activation -121.95352428\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.907198863790789, 8.325278744588815, 1), actual 0\n", + "activation -69.0925500372\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.710739229023136, 0.9315734142648702, 1), actual 0\n", + "activation -114.600326656\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.0930283200245614, 2.025801906750686, 1), actual 0\n", + "activation -18.4241667826\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.2315888872941105, 1.9882133320366713, 1), actual 0\n", + "activation -114.623073399\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.9806349519394395, 9.031509800204056, 1), actual 1\n", + "activation -8.02214824516\n", + "predicted 0, error 1\n", + "Updating weight 0 by 4.9806349519394395\n", + "Updating weight 1 by 9.031509800204056\n", + "Updating weight 2 by 1\n", + "example (8.022792551671591, 8.963715479050858, 1), actual 0\n", + "activation 56.5223840787\n", + "predicted 1, error -1\n", + "Updating weight 0 by -8.022792551671591\n", + "Updating weight 1 by -8.963715479050858\n", + "Updating weight 2 by -1\n", + "example (2.3819906463580685, 6.783367960516962, 1), actual 1\n", + "activation 13.042730567\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.691663780302689, 9.19692948638577, 1), actual 1\n", + "activation 28.6285597294\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.15663629270499, 2.2715570393710327, 1), actual 0\n", + "activation -175.635344167\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.818427898726406, 0.06597202102547328, 1), actual 0\n", + "activation -145.288019551\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3130320726271547, 3.866038256369144, 1), actual 1\n", + "activation -12.4211364281\n", + "predicted 0, error 1\n", + "Updating weight 0 by 2.3130320726271547\n", + "Updating weight 1 by 3.866038256369144\n", + "Updating weight 2 by 1\n", + "example (6.690978851317402, 6.943999836625558, 1), actual 0\n", + "activation -35.6385656568\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.651268612790532, 6.972322990079941, 1), actual 1\n", + "activation 81.8004066349\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.496843709612131, 4.5641606813826066, 1), actual 0\n", + "activation -101.835070818\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.1455617252542005, 3.8130568965414735, 1), actual 0\n", + "activation -85.4881569797\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.376558852812839, 3.8996371469160795, 1), actual 0\n", + "activation -50.0647275633\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.1647757502712945, 5.65257882633725, 1), actual 1\n", + "activation 15.7827191884\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.05745539735547811, 9.527934518916851, 1), actual 1\n", + "activation 126.807621934\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.451583403119836, 0.6826521158120202, 1), actual 0\n", + "activation -16.1531054544\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.596006325563363, 0.20601525116155095, 1), actual 0\n", + "activation -83.348921923\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.818427898726406, 0.06597202102547328, 1), actual 0\n", + "activation -128.261726779\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.6768250252013868, 6.994872275079214, 1), actual 1\n", + "activation 42.8345993796\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.776368485745538, 3.82822551510246, 1), actual 0\n", + "activation -97.5162666145\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.365921435638924, 1.7665655545978187, 1), actual 0\n", + "activation -58.4344842735\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.365921435638924, 1.7665655545978187, 1), actual 0\n", + "activation -58.4344842735\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.9935925736468505, 5.270584030180434, 1), actual 0\n", + "activation -82.8212036882\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.507374437231959, 2.8942089149396413, 1), actual 0\n", + "activation -85.1618450932\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.927844286434178, 3.28726991476319, 1), actual 0\n", + "activation -126.925829257\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.631450050859798, 1.9500588767296667, 1), actual 0\n", + "activation -41.7931083527\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.7152810487220673, 5.142636385860659, 1), actual 1\n", + "activation 56.5772845812\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.4714453635180336, 6.047354839769432, 1), actual 1\n", + "activation 34.396018149\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.662901384102844, 5.365493436584224, 1), actual 0\n", + "activation -17.018389397\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.451583403119836, 0.6826521158120202, 1), actual 0\n", + "activation -16.1531054544\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.9309630662921906, 8.560278192120636, 1), actual 1\n", + "activation 58.4269861006\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.05745539735547811, 9.527934518916851, 1), actual 1\n", + "activation 126.807621934\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.093258189224112, 5.108882558244428, 1), actual 0\n", + "activation -86.872502845\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.653076221592844, 1.3467164503467732, 1), actual 0\n", + "activation -88.8865263372\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.9983266598478, 1.8640958741769331, 1), actual 0\n", + "activation -88.7970365705\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.2315888872941105, 1.9882133320366713, 1), actual 0\n", + "activation -111.074511082\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.451583403119836, 0.6826521158120202, 1), actual 0\n", + "activation -16.1531054544\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.3987984768476194, 6.039436692979809, 1), actual 1\n", + "activation 74.4663559337\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.6104017774044366, 3.774113993604651, 1), actual 1\n", + "activation 21.2894340842\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.631450050859798, 1.9500588767296667, 1), actual 0\n", + "activation -41.7931083527\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.818427898726406, 0.06597202102547328, 1), actual 0\n", + "activation -128.261726779\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.365921435638924, 1.7665655545978187, 1), actual 0\n", + "activation -58.4344842735\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9168198401195615, 2.3879060556407095, 1), actual 1\n", + "activation 16.5636035354\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.4355430271620131, 4.417792135688179, 1), actual 1\n", + "activation 52.4986503096\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.05745539735547811, 9.527934518916851, 1), actual 1\n", + "activation 126.807621934\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.022792551671591, 8.963715479050858, 1), actual 0\n", + "activation -34.9799679926\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.4649859681336621, 9.011384396969206, 1), actual 1\n", + "activation 112.137844484\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.7152810487220673, 5.142636385860659, 1), actual 1\n", + "activation 56.5772845812\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.710739229023136, 0.9315734142648702, 1), actual 0\n", + "activation -114.828644088\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.1647757502712945, 5.65257882633725, 1), actual 1\n", + "activation 15.7827191884\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.508752995382578, 5.336332860186444, 1), actual 0\n", + "activation -53.17875768\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.1647757502712945, 5.65257882633725, 1), actual 1\n", + "activation 15.7827191884\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.376558852812839, 3.8996371469160795, 1), actual 0\n", + "activation -50.0647275633\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.6154114349885442, 3.2139162654620854, 1), actual 1\n", + "activation 33.2326206586\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3962070188044935, 5.021835204430203, 1), actual 1\n", + "activation 22.4125039476\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.2837742452819025, 1.7037136285723686, 1), actual 0\n", + "activation -57.6660480037\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.5448938985282936, 7.797834020938884, 1), actual 1\n", + "activation 94.6825419405\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.741906198125639, 7.276494136007247, 1), actual 0\n", + "activation -71.0335756557\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.518311571730163, 6.768531398973953, 1), actual 0\n", + "activation -92.7406970665\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9856181286237742, 0.664054386459394, 1), actual 0\n", + "activation -7.36506567958\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.764445713683653, 1.424649425018134, 1), actual 0\n", + "activation -167.555723596\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.620754472047351, 6.259532682231028, 1), actual 0\n", + "activation -43.248966488\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.9309630662921906, 8.560278192120636, 1), actual 1\n", + "activation 58.4269861006\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.9935925736468505, 5.270584030180434, 1), actual 0\n", + "activation -82.8212036882\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.496843709612131, 4.5641606813826066, 1), actual 0\n", + "activation -101.835070818\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.4714453635180336, 6.047354839769432, 1), actual 1\n", + "activation 34.396018149\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.651268612790532, 6.972322990079941, 1), actual 1\n", + "activation 81.8004066349\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.3609042458766931, 7.858509647839078, 1), actual 1\n", + "activation 99.0441117366\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.860449470981059, 8.414673599175096, 1), actual 0\n", + "activation 19.1192501094\n", + "predicted 1, error -1\n", + "Updating weight 0 by -4.860449470981059\n", + "Updating weight 1 by -8.414673599175096\n", + "Updating weight 2 by -1\n", + "example (6.710739229023136, 0.9315734142648702, 1), actual 0\n", + "activation -156.284739238\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.68514293424815, 2.663703689110534, 1), actual 0\n", + "activation -74.8054834071\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.2315888872941105, 1.9882133320366713, 1), actual 0\n", + "activation -163.953449698\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.451583403119836, 0.6826521158120202, 1), actual 0\n", + "activation -29.9527479745\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.181485178079948, 7.2791630783924095, 1), actual 0\n", + "activation -162.153426418\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.293153051265162, 3.6596267906380984, 1), actual 0\n", + "activation -133.359097499\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.9309630662921906, 8.560278192120636, 1), actual 1\n", + "activation -28.8507586893\n", + "predicted 0, error 1\n", + "Updating weight 0 by 2.9309630662921906\n", + "Updating weight 1 by 8.560278192120636\n", + "Updating weight 2 by 1\n", + "example (7.079649661953283, 6.659229487453656, 1), actual 0\n", + "activation -59.5952357657\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.905682319649161, 7.02684831070679, 1), actual 1\n", + "activation 34.2344458249\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.1455617252542005, 3.8130568965414735, 1), actual 0\n", + "activation -98.7202225851\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.5042103579704516, 1.5618284566496388, 1), actual 1\n", + "activation 12.9880573671\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.0511694684247652, 3.068483285849682, 1), actual 1\n", + "activation 21.2986457879\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.4714453635180336, 6.047354839769432, 1), actual 1\n", + "activation 30.50792056\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.662901384102844, 5.365493436584224, 1), actual 0\n", + "activation -25.2341537362\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.9983266598478, 1.8640958741769331, 1), actual 0\n", + "activation -100.099305391\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.641925533937323, 6.090415031406695, 1), actual 0\n", + "activation -121.742197088\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.9806349519394395, 9.031509800204056, 1), actual 1\n", + "activation 16.5797530281\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.492335903506584, 2.2501467996671174, 1), actual 0\n", + "activation -169.449024553\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.1647757502712945, 5.65257882633725, 1), actual 1\n", + "activation 10.4993688434\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.401406238607672, 8.470493640496457, 1), actual 1\n", + "activation 64.1144117157\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.451583403119836, 0.6826521158120202, 1), actual 0\n", + "activation -18.8545186126\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9856181286237742, 0.664054386459394, 1), actual 0\n", + "activation -9.17011309034\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.641925533937323, 6.090415031406695, 1), actual 0\n", + "activation -121.742197088\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.15663629270499, 2.2715570393710327, 1), actual 0\n", + "activation -162.01068043\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.706875996441108, 9.923714046947334, 1), actual 0\n", + "activation -72.3238609355\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.093258189224112, 5.108882558244428, 1), actual 0\n", + "activation -101.744457725\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.9745285630306793, 9.699005654934675, 1), actual 1\n", + "activation 46.8686879793\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.03580069578259, 8.4661693659913, 1), actual 1\n", + "activation 50.5365761765\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.2837742452819025, 1.7037136285723686, 1), actual 0\n", + "activation -65.6834636414\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.722727452641504, 5.446057740436029, 1), actual 0\n", + "activation -68.0664617691\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.662901384102844, 5.365493436584224, 1), actual 0\n", + "activation -25.2341537362\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.4649859681336621, 9.011384396969206, 1), actual 1\n", + "activation 112.552759337\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.518311571730163, 6.768531398973953, 1), actual 0\n", + "activation -110.120620581\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.860449470981059, 8.414673599175096, 1), actual 0\n", + "activation 10.9662940586\n", + "predicted 1, error -1\n", + "Updating weight 0 by -4.860449470981059\n", + "Updating weight 1 by -8.414673599175096\n", + "Updating weight 2 by -1\n", + "example (8.927844286434178, 3.28726991476319, 1), actual 0\n", + "activation -215.727981237\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.6104017774044366, 3.774113993604651, 1), actual 1\n", + "activation -21.8534997689\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1.6104017774044366\n", + "Updating weight 1 by 3.774113993604651\n", + "Updating weight 2 by 1\n", + "example (2.0930283200245614, 2.025801906750686, 1), actual 0\n", + "activation -30.9278816109\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.2315888872941105, 1.9882133320366713, 1), actual 0\n", + "activation -157.467701791\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.860449470981059, 8.414673599175096, 1), actual 0\n", + "activation -43.8791929327\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.492335903506584, 2.2501467996671174, 1), actual 0\n", + "activation -210.741509308\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.1119575789514045, 1.7229145080093333, 1), actual 0\n", + "activation -107.689038115\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.653076221592844, 1.3467164503467732, 1), actual 0\n", + "activation -124.220257246\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.05745539735547811, 9.527934518916851, 1), actual 1\n", + "activation 83.6823927182\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.907198863790789, 8.325278744588815, 1), actual 0\n", + "activation -119.484997395\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.8295593621772364, 6.46588813346654, 1), actual 1\n", + "activation -10.7791142379\n", + "predicted 0, error 1\n", + "Updating weight 0 by 2.8295593621772364\n", + "Updating weight 1 by 6.46588813346654\n", + "Updating weight 2 by 1\n", + "example (0.3609042458766931, 7.858509647839078, 1), actual 1\n", + "activation 114.684592822\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.6154114349885442, 3.2139162654620854, 1), actual 1\n", + "activation 39.1208333493\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.4649859681336621, 9.011384396969206, 1), actual 1\n", + "activation 129.805975179\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.741906198125639, 7.276494136007247, 1), actual 0\n", + "activation -76.2353510703\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.68514293424815, 2.663703689110534, 1), actual 0\n", + "activation -35.8898462424\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.601602387823329, 0.3227673378964113, 1), actual 0\n", + "activation -91.1045748191\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.764445713683653, 1.424649425018134, 1), actual 0\n", + "activation -186.694035598\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.860449470981059, 8.414673599175096, 1), actual 0\n", + "activation 25.2820755442\n", + "predicted 1, error -1\n", + "Updating weight 0 by -4.860449470981059\n", + "Updating weight 1 by -8.414673599175096\n", + "Updating weight 2 by -1\n", + "example (0.651268612790532, 6.972322990079941, 1), actual 1\n", + "activation 32.1766437847\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.15663629270499, 2.2715570393710327, 1), actual 0\n", + "activation -225.334380352\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.7200789393907734, 5.496880819540703, 1), actual 1\n", + "activation -6.07847885074\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1.7200789393907734\n", + "Updating weight 1 by 5.496880819540703\n", + "Updating weight 2 by 1\n", + "example (3.4084822494885856, 3.341158023148373, 1), actual 0\n", + "activation -40.1150314284\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.192802215060135, 3.9361834633946446, 1), actual 0\n", + "activation -151.881285494\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.61739680709439, 6.117839361458811, 1), actual 0\n", + "activation -11.5455902103\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.365921435638924, 1.7665655545978187, 1), actual 0\n", + "activation -83.077590025\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.620754472047351, 6.259532682231028, 1), actual 0\n", + "activation -84.5260934518\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.411668814146135, 4.035197667686209, 1), actual 0\n", + "activation -31.754419705\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.9806349519394395, 9.031509800204056, 1), actual 1\n", + "activation -10.0221866798\n", + "predicted 0, error 1\n", + "Updating weight 0 by 4.9806349519394395\n", + "Updating weight 1 by 9.031509800204056\n", + "Updating weight 2 by 1\n", + "example (2.691663780302689, 9.19692948638577, 1), actual 1\n", + "activation 146.392134095\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.690978851317402, 6.943999836625558, 1), actual 0\n", + "activation 19.0907826615\n", + "predicted 1, error -1\n", + "Updating weight 0 by -6.690978851317402\n", + "Updating weight 1 by -6.943999836625558\n", + "Updating weight 2 by -1\n", + "example (5.9983266598478, 1.8640958741769331, 1), actual 0\n", + "activation -128.862840844\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.690978851317402, 6.943999836625558, 1), actual 0\n", + "activation -74.8975490584\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.631450050859798, 1.9500588767296667, 1), actual 0\n", + "activation -64.7177161425\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.448079300022808, 3.103095683918884, 1), actual 0\n", + "activation -149.749333563\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.09874190336673583, 6.382227853095017, 1), actual 1\n", + "activation 92.3443228091\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.03580069578259, 8.4661693659913, 1), actual 1\n", + "activation 43.9584806862\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.411668814146135, 4.035197667686209, 1), actual 0\n", + "activation -29.1660313116\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.776368485745538, 3.82822551510246, 1), actual 0\n", + "activation -148.144812328\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.3987984768476194, 6.039436692979809, 1), actual 1\n", + "activation 79.4836173662\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.620754472047351, 6.259532682231028, 1), actual 0\n", + "activation -82.7830236308\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.620754472047351, 6.259532682231028, 1), actual 0\n", + "activation -82.7830236308\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.443170896641262, 9.351637036828835, 1), actual 0\n", + "activation -7.4221549135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.9983266598478, 1.8640958741769331, 1), actual 0\n", + "activation -128.862840844\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.727355694553044, 0.3776260800598663, 1), actual 0\n", + "activation -196.006062161\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.710739229023136, 0.9315734142648702, 1), actual 0\n", + "activation -161.087991858\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.1455617252542005, 3.8130568965414735, 1), actual 0\n", + "activation -131.591761376\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.672673354327543, 3.946823625401171, 1), actual 1\n", + "activation 15.8037365482\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.5448938985282936, 7.797834020938884, 1), actual 1\n", + "activation 100.653532101\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3962070188044935, 5.021835204430203, 1), actual 1\n", + "activation 11.8863198818\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.620754472047351, 6.259532682231028, 1), actual 0\n", + "activation -82.7830236308\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.093258189224112, 5.108882558244428, 1), actual 0\n", + "activation -138.322090967\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.630182521583322, 2.6250709133395436, 1), actual 0\n", + "activation -214.568600909\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.46967309343628, 9.666354617521636, 1), actual 0\n", + "activation -83.3936613714\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.18767455738911, 9.398469126153845, 1), actual 1\n", + "activation 0.0371457770942\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.662901384102844, 5.365493436584224, 1), actual 0\n", + "activation -43.4743411568\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.9309630662921906, 8.560278192120636, 1), actual 1\n", + "activation 48.086316029\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.46967309343628, 9.666354617521636, 1), actual 0\n", + "activation -83.3936613714\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.4714453635180336, 6.047354839769432, 1), actual 1\n", + "activation 24.4978254341\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.917163743267875, 6.542643315036429, 1), actual 0\n", + "activation -6.87783163557\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9168198401195615, 2.3879060556407095, 1), actual 1\n", + "activation 13.6856346147\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.192802215060135, 3.9361834633946446, 1), actual 0\n", + "activation -157.676972583\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.450406859792585, 1.4683907453208889, 1), actual 0\n", + "activation -93.3514275639\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.908942264364572, 7.697005742911313, 1), actual 1\n", + "activation 9.78809827574\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9856181286237742, 0.664054386459394, 1), actual 0\n", + "activation -12.7047416229\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.09874190336673583, 6.382227853095017, 1), actual 1\n", + "activation 92.3443228091\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.508752995382578, 5.336332860186444, 1), actual 0\n", + "activation -92.9593751615\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.376558852812839, 3.8996371469160795, 1), actual 0\n", + "activation -83.3315343506\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.448079300022808, 3.103095683918884, 1), actual 0\n", + "activation -149.749333563\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.875266984278501, 4.490679281547934, 1), actual 0\n", + "activation -61.5841679901\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.641925533937323, 6.090415031406695, 1), actual 0\n", + "activation -165.506500236\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.508752995382578, 5.336332860186444, 1), actual 0\n", + "activation -92.9593751615\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9856181286237742, 0.664054386459394, 1), actual 0\n", + "activation -12.7047416229\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.270048303565226, 4.145168925603738, 1), actual 0\n", + "activation -130.16913742\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.68514293424815, 2.663703689110534, 1), actual 0\n", + "activation -55.9770496539\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.1119575789514045, 1.7229145080093333, 1), actual 0\n", + "activation -107.311430925\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.079649661953283, 6.659229487453656, 1), actual 0\n", + "activation -89.2872668747\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.0930283200245614, 2.025801906750686, 1), actual 0\n", + "activation -22.7415964113\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.727355694553044, 0.3776260800598663, 1), actual 0\n", + "activation -196.006062161\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.365921435638924, 1.7665655545978187, 1), actual 0\n", + "activation -86.8570939211\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.908942264364572, 7.697005742911313, 1), actual 1\n", + "activation 9.78809827574\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.192802215060135, 3.9361834633946446, 1), actual 0\n", + "activation -157.676972583\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.875266984278501, 4.490679281547934, 1), actual 0\n", + "activation -61.5841679901\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3072146878925337, 1.0590975460143037, 1), actual 0\n", + "activation -42.2090789602\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.451583403119836, 0.6826521158120202, 1), actual 0\n", + "activation -24.8268389964\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.9935925736468505, 5.270584030180434, 1), actual 0\n", + "activation -133.368685859\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.09874190336673583, 6.382227853095017, 1), actual 1\n", + "activation 92.3443228091\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.192802215060135, 3.9361834633946446, 1), actual 0\n", + "activation -157.676972583\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.09874190336673583, 6.382227853095017, 1), actual 1\n", + "activation 92.3443228091\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.907198863790789, 8.325278744588815, 1), actual 0\n", + "activation -87.5486872971\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.24631434468817104, 5.173384257803269, 1), actual 1\n", + "activation 71.1976811438\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.910197726504086, 2.663137790168496, 1), actual 0\n", + "activation -8.80051300832\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.508752995382578, 5.336332860186444, 1), actual 0\n", + "activation -92.9593751615\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.46967309343628, 9.666354617521636, 1), actual 0\n", + "activation -83.3936613714\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.376558852812839, 3.8996371469160795, 1), actual 0\n", + "activation -83.3315343506\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.672673354327543, 3.946823625401171, 1), actual 1\n", + "activation 15.8037365482\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.722727452641504, 5.446057740436029, 1), actual 0\n", + "activation -97.084244887\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.908942264364572, 7.697005742911313, 1), actual 1\n", + "activation 9.78809827574\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.451583403119836, 0.6826521158120202, 1), actual 0\n", + "activation -24.8268389964\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.365921435638924, 1.7665655545978187, 1), actual 0\n", + "activation -86.8570939211\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9272066167158133, 1.9791743425547825, 1), actual 1\n", + "activation 7.58590034469\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.672673354327543, 3.946823625401171, 1), actual 1\n", + "activation 15.8037365482\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.18767455738911, 9.398469126153845, 1), actual 1\n", + "activation 0.0371457770942\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.181485178079948, 7.2791630783924095, 1), actual 0\n", + "activation -109.745301841\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.7200789393907734, 5.496880819540703, 1), actual 1\n", + "activation 36.6287584102\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.4084822494885856, 3.341158023148373, 1), actual 0\n", + "activation -38.9700075868\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.727355694553044, 0.3776260800598663, 1), actual 0\n", + "activation -196.006062161\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.192802215060135, 3.9361834633946446, 1), actual 0\n", + "activation -157.676972583\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.46967309343628, 9.666354617521636, 1), actual 0\n", + "activation -83.3936613714\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.651268612790532, 6.972322990079941, 1), actual 1\n", + "activation 86.0638061336\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.672673354327543, 3.946823625401171, 1), actual 1\n", + "activation 15.8037365482\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.0511694684247652, 3.068483285849682, 1), actual 1\n", + "activation 19.8109995177\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9856181286237742, 0.664054386459394, 1), actual 0\n", + "activation -12.7047416229\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.907198863790789, 8.325278744588815, 1), actual 0\n", + "activation -87.5486872971\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.631450050859798, 1.9500588767296667, 1), actual 0\n", + "activation -64.7177161425\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.585454104080487, 9.497175946383228, 1), actual 1\n", + "activation 97.2038468411\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.818427898726406, 0.06597202102547328, 1), actual 0\n", + "activation -176.28385568\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.508752995382578, 5.336332860186444, 1), actual 0\n", + "activation -92.9593751615\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.910197726504086, 2.663137790168496, 1), actual 0\n", + "activation -8.80051300832\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.764445713683653, 1.424649425018134, 1), actual 0\n", + "activation -235.241435268\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.376558852812839, 3.8996371469160795, 1), actual 0\n", + "activation -83.3315343506\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.776368485745538, 3.82822551510246, 1), actual 0\n", + "activation -148.144812328\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.022792551671591, 8.963715479050858, 1), actual 0\n", + "activation -81.5251386157\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.672673354327543, 3.946823625401171, 1), actual 1\n", + "activation 15.8037365482\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.03580069578259, 8.4661693659913, 1), actual 1\n", + "activation 43.9584806862\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.706875996441108, 9.923714046947334, 1), actual 0\n", + "activation -112.616223394\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.376558852812839, 3.8996371469160795, 1), actual 0\n", + "activation -83.3315343506\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.508752995382578, 5.336332860186444, 1), actual 0\n", + "activation -92.9593751615\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.68514293424815, 2.663703689110534, 1), actual 0\n", + "activation -55.9770496539\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.0930283200245614, 2.025801906750686, 1), actual 0\n", + "activation -22.7415964113\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3962070188044935, 5.021835204430203, 1), actual 1\n", + "activation 11.8863198818\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.0930283200245614, 2.025801906750686, 1), actual 0\n", + "activation -22.7415964113\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.860449470981059, 8.414673599175096, 1), actual 0\n", + "activation -5.28113573775\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.620754472047351, 6.259532682231028, 1), actual 0\n", + "activation -82.7830236308\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9856181286237742, 0.664054386459394, 1), actual 0\n", + "activation -12.7047416229\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.9806349519394395, 9.031509800204056, 1), actual 1\n", + "activation 0.31258140923\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.776368485745538, 3.82822551510246, 1), actual 0\n", + "activation -148.144812328\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.4256695234516705, 0.3391835724830805, 1), actual 0\n", + "activation -135.366471603\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3819906463580685, 6.783367960516962, 1), actual 1\n", + "activation 37.3625878595\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.9806349519394395, 9.031509800204056, 1), actual 1\n", + "activation 0.31258140923\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.05745539735547811, 9.527934518916851, 1), actual 1\n", + "activation 138.261944889\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.448079300022808, 3.103095683918884, 1), actual 0\n", + "activation -149.749333563\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.672673354327543, 3.946823625401171, 1), actual 1\n", + "activation 15.8037365482\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.727355694553044, 0.3776260800598663, 1), actual 0\n", + "activation -196.006062161\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.691663780302689, 9.19692948638577, 1), actual 1\n", + "activation 63.5187918151\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.376558852812839, 3.8996371469160795, 1), actual 0\n", + "activation -83.3315343506\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.3987984768476194, 6.039436692979809, 1), actual 1\n", + "activation 79.4836173662\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.727355694553044, 0.3776260800598663, 1), actual 0\n", + "activation -196.006062161\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.2837742452819025, 1.7037136285723686, 1), actual 0\n", + "activation -85.5688333362\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.764445713683653, 1.424649425018134, 1), actual 0\n", + "activation -235.241435268\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.5448938985282936, 7.797834020938884, 1), actual 1\n", + "activation 100.653532101\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.927844286434178, 3.28726991476319, 1), actual 0\n", + "activation -186.462835465\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.450406859792585, 1.4683907453208889, 1), actual 0\n", + "activation -93.3514275639\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.907198863790789, 8.325278744588815, 1), actual 0\n", + "activation -87.5486872971\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.448079300022808, 3.103095683918884, 1), actual 0\n", + "activation -149.749333563\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.05745539735547811, 9.527934518916851, 1), actual 1\n", + "activation 138.261944889\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.4084822494885856, 3.341158023148373, 1), actual 0\n", + "activation -38.9700075868\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.093258189224112, 5.108882558244428, 1), actual 0\n", + "activation -138.322090967\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.3609042458766931, 7.858509647839078, 1), actual 1\n", + "activation 106.409163868\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.451583403119836, 0.6826521158120202, 1), actual 0\n", + "activation -24.8268389964\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.270048303565226, 4.145168925603738, 1), actual 0\n", + "activation -130.16913742\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.9309630662921906, 8.560278192120636, 1), actual 1\n", + "activation 48.086316029\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.4084822494885856, 3.341158023148373, 1), actual 0\n", + "activation -38.9700075868\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.917163743267875, 6.542643315036429, 1), actual 0\n", + "activation -6.87783163557\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.365921435638924, 1.7665655545978187, 1), actual 0\n", + "activation -86.8570939211\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.875266984278501, 4.490679281547934, 1), actual 0\n", + "activation -61.5841679901\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.18767455738911, 9.398469126153845, 1), actual 1\n", + "activation 0.0371457770942\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.672673354327543, 3.946823625401171, 1), actual 1\n", + "activation 15.8037365482\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.908942264364572, 7.697005742911313, 1), actual 1\n", + "activation 9.78809827574\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.4714453635180336, 6.047354839769432, 1), actual 1\n", + "activation 24.4978254341\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.4084822494885856, 3.341158023148373, 1), actual 0\n", + "activation -38.9700075868\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.776368485745538, 3.82822551510246, 1), actual 0\n", + "activation -148.144812328\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.181485178079948, 7.2791630783924095, 1), actual 0\n", + "activation -109.745301841\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.450406859792585, 1.4683907453208889, 1), actual 0\n", + "activation -93.3514275639\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.293153051265162, 3.6596267906380984, 1), actual 0\n", + "activation -111.117664731\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.365921435638924, 1.7665655545978187, 1), actual 0\n", + "activation -86.8570939211\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.7152810487220673, 5.142636385860659, 1), actual 1\n", + "activation 58.2927178432\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.507374437231959, 2.8942089149396413, 1), actual 0\n", + "activation -127.718145428\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.079649661953283, 6.659229487453656, 1), actual 0\n", + "activation -89.2872668747\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.05745539735547811, 9.527934518916851, 1), actual 1\n", + "activation 138.261944889\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.496843709612131, 4.5641606813826066, 1), actual 0\n", + "activation -156.812089999\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3962070188044935, 5.021835204430203, 1), actual 1\n", + "activation 11.8863198818\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9856181286237742, 0.664054386459394, 1), actual 0\n", + "activation -12.7047416229\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.9935925736468505, 5.270584030180434, 1), actual 0\n", + "activation -133.368685859\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.270048303565226, 4.145168925603738, 1), actual 0\n", + "activation -130.16913742\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.0930283200245614, 2.025801906750686, 1), actual 0\n", + "activation -22.7415964113\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.443170896641262, 9.351637036828835, 1), actual 0\n", + "activation -7.4221549135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.9983266598478, 1.8640958741769331, 1), actual 0\n", + "activation -128.862840844\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.376558852812839, 3.8996371469160795, 1), actual 0\n", + "activation -83.3315343506\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.174597655432761, 6.050566632049054, 1), actual 0\n", + "activation -47.3161852195\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.429595407669325, 2.1741339470916223, 1), actual 0\n", + "activation -189.077517361\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.46967309343628, 9.666354617521636, 1), actual 0\n", + "activation -83.3936613714\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.0930283200245614, 2.025801906750686, 1), actual 0\n", + "activation -22.7415964113\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.691663780302689, 9.19692948638577, 1), actual 1\n", + "activation 63.5187918151\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.7200789393907734, 5.496880819540703, 1), actual 1\n", + "activation 36.6287584102\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.174597655432761, 6.050566632049054, 1), actual 0\n", + "activation -47.3161852195\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9272066167158133, 1.9791743425547825, 1), actual 1\n", + "activation 7.58590034469\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9168198401195615, 2.3879060556407095, 1), actual 1\n", + "activation 13.6856346147\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.079649661953283, 6.659229487453656, 1), actual 0\n", + "activation -89.2872668747\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.24631434468817104, 5.173384257803269, 1), actual 1\n", + "activation 71.1976811438\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.68514293424815, 2.663703689110534, 1), actual 0\n", + "activation -55.9770496539\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.093258189224112, 5.108882558244428, 1), actual 0\n", + "activation -138.322090967\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.5448938985282936, 7.797834020938884, 1), actual 1\n", + "activation 100.653532101\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3819906463580685, 6.783367960516962, 1), actual 1\n", + "activation 37.3625878595\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.6768250252013868, 6.994872275079214, 1), actual 1\n", + "activation 32.538317611\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.6104017774044366, 3.774113993604651, 1), actual 1\n", + "activation 14.9983757281\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3072146878925337, 1.0590975460143037, 1), actual 0\n", + "activation -42.2090789602\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3962070188044935, 5.021835204430203, 1), actual 1\n", + "activation 11.8863198818\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.1647757502712945, 5.65257882633725, 1), actual 1\n", + "activation 0.441768488299\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.429595407669325, 2.1741339470916223, 1), actual 0\n", + "activation -189.077517361\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.917163743267875, 6.542643315036429, 1), actual 0\n", + "activation -6.87783163557\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.1455617252542005, 3.8130568965414735, 1), actual 0\n", + "activation -131.591761376\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9272066167158133, 1.9791743425547825, 1), actual 1\n", + "activation 7.58590034469\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.722727452641504, 5.446057740436029, 1), actual 0\n", + "activation -97.084244887\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.61739680709439, 6.117839361458811, 1), actual 0\n", + "activation -4.96153214837\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9856181286237742, 0.664054386459394, 1), actual 0\n", + "activation -12.7047416229\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.905682319649161, 7.02684831070679, 1), actual 1\n", + "activation 26.9100404344\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.917163743267875, 6.542643315036429, 1), actual 0\n", + "activation -6.87783163557\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3072146878925337, 1.0590975460143037, 1), actual 0\n", + "activation -42.2090789602\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.691663780302689, 9.19692948638577, 1), actual 1\n", + "activation 63.5187918151\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9168198401195615, 2.3879060556407095, 1), actual 1\n", + "activation 13.6856346147\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.61739680709439, 6.117839361458811, 1), actual 0\n", + "activation -4.96153214837\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.917163743267875, 6.542643315036429, 1), actual 0\n", + "activation -6.87783163557\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.9309630662921906, 8.560278192120636, 1), actual 1\n", + "activation 48.086316029\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.05745539735547811, 9.527934518916851, 1), actual 1\n", + "activation 138.261944889\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.7200789393907734, 5.496880819540703, 1), actual 1\n", + "activation 36.6287584102\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.9745285630306793, 9.699005654934675, 1), actual 1\n", + "activation 36.5690960248\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.620754472047351, 6.259532682231028, 1), actual 0\n", + "activation -82.7830236308\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.293153051265162, 3.6596267906380984, 1), actual 0\n", + "activation -111.117664731\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.496843709612131, 4.5641606813826066, 1), actual 0\n", + "activation -156.812089999\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.68514293424815, 2.663703689110534, 1), actual 0\n", + "activation -55.9770496539\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.690978851317402, 6.943999836625558, 1), actual 0\n", + "activation -74.8975490584\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.907198863790789, 8.325278744588815, 1), actual 0\n", + "activation -87.5486872971\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.818427898726406, 0.06597202102547328, 1), actual 0\n", + "activation -176.28385568\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9272066167158133, 1.9791743425547825, 1), actual 1\n", + "activation 7.58590034469\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.907198863790789, 8.325278744588815, 1), actual 0\n", + "activation -87.5486872971\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.3609042458766931, 7.858509647839078, 1), actual 1\n", + "activation 106.409163868\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.508752995382578, 5.336332860186444, 1), actual 0\n", + "activation -92.9593751615\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.3987984768476194, 6.039436692979809, 1), actual 1\n", + "activation 79.4836173662\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.690978851317402, 6.943999836625558, 1), actual 0\n", + "activation -74.8975490584\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.518311571730163, 6.768531398973953, 1), actual 0\n", + "activation -152.558572687\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.818427898726406, 0.06597202102547328, 1), actual 0\n", + "activation -176.28385568\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.03580069578259, 8.4661693659913, 1), actual 1\n", + "activation 43.9584806862\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.8295593621772364, 6.46588813346654, 1), actual 1\n", + "activation 20.9411010616\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.875266984278501, 4.490679281547934, 1), actual 0\n", + "activation -61.5841679901\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.1455617252542005, 3.8130568965414735, 1), actual 0\n", + "activation -131.591761376\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.620754472047351, 6.259532682231028, 1), actual 0\n", + "activation -82.7830236308\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.727355694553044, 0.3776260800598663, 1), actual 0\n", + "activation -196.006062161\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.4355430271620131, 4.417792135688179, 1), actual 1\n", + "activation 55.4015962981\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.518311571730163, 6.768531398973953, 1), actual 0\n", + "activation -152.558572687\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.620754472047351, 6.259532682231028, 1), actual 0\n", + "activation -82.7830236308\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.4256695234516705, 0.3391835724830805, 1), actual 0\n", + "activation -135.366471603\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3072146878925337, 1.0590975460143037, 1), actual 0\n", + "activation -42.2090789602\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.05745539735547811, 9.527934518916851, 1), actual 1\n", + "activation 138.261944889\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.641925533937323, 6.090415031406695, 1), actual 0\n", + "activation -165.506500236\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.9309630662921906, 8.560278192120636, 1), actual 1\n", + "activation 48.086316029\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.1455617252542005, 3.8130568965414735, 1), actual 0\n", + "activation -131.591761376\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.7152810487220673, 5.142636385860659, 1), actual 1\n", + "activation 58.2927178432\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.46967309343628, 9.666354617521636, 1), actual 0\n", + "activation -83.3936613714\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.4649859681336621, 9.011384396969206, 1), actual 1\n", + "activation 120.06846342\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.653076221592844, 1.3467164503467732, 1), actual 0\n", + "activation -127.056438517\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.401406238607672, 8.470493640496457, 1), actual 1\n", + "activation 60.8846408913\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.710739229023136, 0.9315734142648702, 1), actual 0\n", + "activation -161.087991858\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.4649859681336621, 9.011384396969206, 1), actual 1\n", + "activation 120.06846342\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.05745539735547811, 9.527934518916851, 1), actual 1\n", + "activation 138.261944889\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.15663629270499, 2.2715570393710327, 1), actual 0\n", + "activation -207.016863859\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9168198401195615, 2.3879060556407095, 1), actual 1\n", + "activation 13.6856346147\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.818427898726406, 0.06597202102547328, 1), actual 0\n", + "activation -176.28385568\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.706875996441108, 9.923714046947334, 1), actual 0\n", + "activation -112.616223394\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.905682319649161, 7.02684831070679, 1), actual 1\n", + "activation 26.9100404344\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.7200789393907734, 5.496880819540703, 1), actual 1\n", + "activation 36.6287584102\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.927844286434178, 3.28726991476319, 1), actual 0\n", + "activation -186.462835465\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3072146878925337, 1.0590975460143037, 1), actual 0\n", + "activation -42.2090789602\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.05745539735547811, 9.527934518916851, 1), actual 1\n", + "activation 138.261944889\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.09874190336673583, 6.382227853095017, 1), actual 1\n", + "activation 92.3443228091\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.24631434468817104, 5.173384257803269, 1), actual 1\n", + "activation 71.1976811438\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.9935925736468505, 5.270584030180434, 1), actual 0\n", + "activation -133.368685859\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.662901384102844, 5.365493436584224, 1), actual 0\n", + "activation -43.4743411568\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.6768250252013868, 6.994872275079214, 1), actual 1\n", + "activation 32.538317611\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.4084822494885856, 3.341158023148373, 1), actual 0\n", + "activation -38.9700075868\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.9983266598478, 1.8640958741769331, 1), actual 0\n", + "activation -128.862840844\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.662901384102844, 5.365493436584224, 1), actual 0\n", + "activation -43.4743411568\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.61739680709439, 6.117839361458811, 1), actual 0\n", + "activation -4.96153214837\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9856181286237742, 0.664054386459394, 1), actual 0\n", + "activation -12.7047416229\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9272066167158133, 1.9791743425547825, 1), actual 1\n", + "activation 7.58590034469\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3819906463580685, 6.783367960516962, 1), actual 1\n", + "activation 37.3625878595\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.741906198125639, 7.276494136007247, 1), actual 0\n", + "activation -124.681389662\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.630182521583322, 2.6250709133395436, 1), actual 0\n", + "activation -214.568600909\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.451583403119836, 0.6826521158120202, 1), actual 0\n", + "activation -24.8268389964\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.596006325563363, 0.20601525116155095, 1), actual 0\n", + "activation -115.208343524\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9168198401195615, 2.3879060556407095, 1), actual 1\n", + "activation 13.6856346147\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.09874190336673583, 6.382227853095017, 1), actual 1\n", + "activation 92.3443228091\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.606562632219457, 1.636997760425708, 1), actual 0\n", + "activation -201.435084025\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.61739680709439, 6.117839361458811, 1), actual 0\n", + "activation -4.96153214837\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.293153051265162, 3.6596267906380984, 1), actual 0\n", + "activation -111.117664731\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.093258189224112, 5.108882558244428, 1), actual 0\n", + "activation -138.322090967\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.741906198125639, 7.276494136007247, 1), actual 0\n", + "activation -124.681389662\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.710739229023136, 0.9315734142648702, 1), actual 0\n", + "activation -161.087991858\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.9935925736468505, 5.270584030180434, 1), actual 0\n", + "activation -133.368685859\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9856181286237742, 0.664054386459394, 1), actual 0\n", + "activation -12.7047416229\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.174597655432761, 6.050566632049054, 1), actual 0\n", + "activation -47.3161852195\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.4649859681336621, 9.011384396969206, 1), actual 1\n", + "activation 120.06846342\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9168198401195615, 2.3879060556407095, 1), actual 1\n", + "activation 13.6856346147\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.651268612790532, 6.972322990079941, 1), actual 1\n", + "activation 86.0638061336\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.3279565582768065, 7.106134092027016, 1), actual 0\n", + "activation -36.3532908076\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.43628818342939, 6.982136553712499, 1), actual 0\n", + "activation -14.416170653\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.6768250252013868, 6.994872275079214, 1), actual 1\n", + "activation 32.538317611\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.4714453635180336, 6.047354839769432, 1), actual 1\n", + "activation 24.4978254341\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.7200789393907734, 5.496880819540703, 1), actual 1\n", + "activation 36.6287584102\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.079649661953283, 6.659229487453656, 1), actual 0\n", + "activation -89.2872668747\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.3609042458766931, 7.858509647839078, 1), actual 1\n", + "activation 106.409163868\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.631450050859798, 1.9500588767296667, 1), actual 0\n", + "activation -64.7177161425\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.7200789393907734, 5.496880819540703, 1), actual 1\n", + "activation 36.6287584102\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3072146878925337, 1.0590975460143037, 1), actual 0\n", + "activation -42.2090789602\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.9745285630306793, 9.699005654934675, 1), actual 1\n", + "activation 36.5690960248\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.03580069578259, 8.4661693659913, 1), actual 1\n", + "activation 43.9584806862\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.620754472047351, 6.259532682231028, 1), actual 0\n", + "activation -82.7830236308\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.601602387823329, 0.3227673378964113, 1), actual 0\n", + "activation -113.693622102\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.7152810487220673, 5.142636385860659, 1), actual 1\n", + "activation 58.2927178432\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.722727452641504, 5.446057740436029, 1), actual 0\n", + "activation -97.084244887\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.079649661953283, 6.659229487453656, 1), actual 0\n", + "activation -89.2872668747\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.620754472047351, 6.259532682231028, 1), actual 0\n", + "activation -82.7830236308\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.376558852812839, 3.8996371469160795, 1), actual 0\n", + "activation -83.3315343506\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.293153051265162, 3.6596267906380984, 1), actual 0\n", + "activation -111.117664731\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.672673354327543, 3.946823625401171, 1), actual 1\n", + "activation 15.8037365482\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.411668814146135, 4.035197667686209, 1), actual 0\n", + "activation -29.1660313116\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.492335903506584, 2.2501467996671174, 1), actual 0\n", + "activation -216.246052864\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.706875996441108, 9.923714046947334, 1), actual 0\n", + "activation -112.616223394\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.6104017774044366, 3.774113993604651, 1), actual 1\n", + "activation 14.9983757281\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.68514293424815, 2.663703689110534, 1), actual 0\n", + "activation -55.9770496539\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.601602387823329, 0.3227673378964113, 1), actual 0\n", + "activation -113.693622102\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.910197726504086, 2.663137790168496, 1), actual 0\n", + "activation -8.80051300832\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.6104017774044366, 3.774113993604651, 1), actual 1\n", + "activation 14.9983757281\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.0511694684247652, 3.068483285849682, 1), actual 1\n", + "activation 19.8109995177\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.910197726504086, 2.663137790168496, 1), actual 0\n", + "activation -8.80051300832\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.910197726504086, 2.663137790168496, 1), actual 0\n", + "activation -8.80051300832\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3819906463580685, 6.783367960516962, 1), actual 1\n", + "activation 37.3625878595\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.917163743267875, 6.542643315036429, 1), actual 0\n", + "activation -6.87783163557\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.1119575789514045, 1.7229145080093333, 1), actual 0\n", + "activation -107.311430925\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.727355694553044, 0.3776260800598663, 1), actual 0\n", + "activation -196.006062161\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.1455617252542005, 3.8130568965414735, 1), actual 0\n", + "activation -131.591761376\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.5448938985282936, 7.797834020938884, 1), actual 1\n", + "activation 100.653532101\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.641925533937323, 6.090415031406695, 1), actual 0\n", + "activation -165.506500236\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.691663780302689, 9.19692948638577, 1), actual 1\n", + "activation 63.5187918151\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.927844286434178, 3.28726991476319, 1), actual 0\n", + "activation -186.462835465\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.776368485745538, 3.82822551510246, 1), actual 0\n", + "activation -148.144812328\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.690978851317402, 6.943999836625558, 1), actual 0\n", + "activation -74.8975490584\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.6768250252013868, 6.994872275079214, 1), actual 1\n", + "activation 32.538317611\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.18767455738911, 9.398469126153845, 1), actual 1\n", + "activation 0.0371457770942\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.917163743267875, 6.542643315036429, 1), actual 0\n", + "activation -6.87783163557\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.2315888872941105, 1.9882133320366713, 1), actual 0\n", + "activation -159.8790787\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.079649661953283, 6.659229487453656, 1), actual 0\n", + "activation -89.2872668747\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.2315888872941105, 1.9882133320366713, 1), actual 0\n", + "activation -159.8790787\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.1119575789514045, 1.7229145080093333, 1), actual 0\n", + "activation -107.311430925\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.6768250252013868, 6.994872275079214, 1), actual 1\n", + "activation 32.538317611\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3072146878925337, 1.0590975460143037, 1), actual 0\n", + "activation -42.2090789602\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.093258189224112, 5.108882558244428, 1), actual 0\n", + "activation -138.322090967\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.651268612790532, 6.972322990079941, 1), actual 1\n", + "activation 86.0638061336\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.691663780302689, 9.19692948638577, 1), actual 1\n", + "activation 63.5187918151\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.093258189224112, 5.108882558244428, 1), actual 0\n", + "activation -138.322090967\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.401406238607672, 8.470493640496457, 1), actual 1\n", + "activation 60.8846408913\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.05745539735547811, 9.527934518916851, 1), actual 1\n", + "activation 138.261944889\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.8196945752536577, 5.205272887963199, 1), actual 1\n", + "activation 56.4094664364\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.6104017774044366, 3.774113993604651, 1), actual 1\n", + "activation 14.9983757281\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.875266984278501, 4.490679281547934, 1), actual 0\n", + "activation -61.5841679901\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.24631434468817104, 5.173384257803269, 1), actual 1\n", + "activation 71.1976811438\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.492335903506584, 2.2501467996671174, 1), actual 0\n", + "activation -216.246052864\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.5042103579704516, 1.5618284566496388, 1), actual 1\n", + "activation 12.8843530437\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.508752995382578, 5.336332860186444, 1), actual 0\n", + "activation -92.9593751615\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.905682319649161, 7.02684831070679, 1), actual 1\n", + "activation 26.9100404344\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.401406238607672, 8.470493640496457, 1), actual 1\n", + "activation 60.8846408913\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3962070188044935, 5.021835204430203, 1), actual 1\n", + "activation 11.8863198818\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.022792551671591, 8.963715479050858, 1), actual 0\n", + "activation -81.5251386157\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.192802215060135, 3.9361834633946446, 1), actual 0\n", + "activation -157.676972583\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.606562632219457, 1.636997760425708, 1), actual 0\n", + "activation -201.435084025\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.907198863790789, 8.325278744588815, 1), actual 0\n", + "activation -87.5486872971\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.727355694553044, 0.3776260800598663, 1), actual 0\n", + "activation -196.006062161\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.518311571730163, 6.768531398973953, 1), actual 0\n", + "activation -152.558572687\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.917163743267875, 6.542643315036429, 1), actual 0\n", + "activation -6.87783163557\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.5448938985282936, 7.797834020938884, 1), actual 1\n", + "activation 100.653532101\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.2315888872941105, 1.9882133320366713, 1), actual 0\n", + "activation -159.8790787\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.508752995382578, 5.336332860186444, 1), actual 0\n", + "activation -92.9593751615\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.022792551671591, 8.963715479050858, 1), actual 0\n", + "activation -81.5251386157\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.450406859792585, 1.4683907453208889, 1), actual 0\n", + "activation -93.3514275639\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.710739229023136, 0.9315734142648702, 1), actual 0\n", + "activation -161.087991858\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.9309630662921906, 8.560278192120636, 1), actual 1\n", + "activation 48.086316029\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.1455617252542005, 3.8130568965414735, 1), actual 0\n", + "activation -131.591761376\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.450406859792585, 1.4683907453208889, 1), actual 0\n", + "activation -93.3514275639\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.093258189224112, 5.108882558244428, 1), actual 0\n", + "activation -138.322090967\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.3609042458766931, 7.858509647839078, 1), actual 1\n", + "activation 106.409163868\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.741906198125639, 7.276494136007247, 1), actual 0\n", + "activation -124.681389662\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.596006325563363, 0.20601525116155095, 1), actual 0\n", + "activation -115.208343524\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.776368485745538, 3.82822551510246, 1), actual 0\n", + "activation -148.144812328\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.365921435638924, 1.7665655545978187, 1), actual 0\n", + "activation -86.8570939211\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.7152810487220673, 5.142636385860659, 1), actual 1\n", + "activation 58.2927178432\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.448079300022808, 3.103095683918884, 1), actual 0\n", + "activation -149.749333563\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.05745539735547811, 9.527934518916851, 1), actual 1\n", + "activation 138.261944889\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.1455617252542005, 3.8130568965414735, 1), actual 0\n", + "activation -131.591761376\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.927844286434178, 3.28726991476319, 1), actual 0\n", + "activation -186.462835465\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.6154114349885442, 3.2139162654620854, 1), actual 1\n", + "activation 33.4671887732\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.03580069578259, 8.4661693659913, 1), actual 1\n", + "activation 43.9584806862\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.376558852812839, 3.8996371469160795, 1), actual 0\n", + "activation -83.3315343506\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.174597655432761, 6.050566632049054, 1), actual 0\n", + "activation -47.3161852195\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.620754472047351, 6.259532682231028, 1), actual 0\n", + "activation -82.7830236308\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.293153051265162, 3.6596267906380984, 1), actual 0\n", + "activation -111.117664731\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.2837742452819025, 1.7037136285723686, 1), actual 0\n", + "activation -85.5688333362\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.662901384102844, 5.365493436584224, 1), actual 0\n", + "activation -43.4743411568\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.908942264364572, 7.697005742911313, 1), actual 1\n", + "activation 9.78809827574\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.4256695234516705, 0.3391835724830805, 1), actual 0\n", + "activation -135.366471603\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.907198863790789, 8.325278744588815, 1), actual 0\n", + "activation -87.5486872971\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.4084822494885856, 3.341158023148373, 1), actual 0\n", + "activation -38.9700075868\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.9745285630306793, 9.699005654934675, 1), actual 1\n", + "activation 36.5690960248\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9272066167158133, 1.9791743425547825, 1), actual 1\n", + "activation 7.58590034469\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.776368485745538, 3.82822551510246, 1), actual 0\n", + "activation -148.144812328\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.776368485745538, 3.82822551510246, 1), actual 0\n", + "activation -148.144812328\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.630182521583322, 2.6250709133395436, 1), actual 0\n", + "activation -214.568600909\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.293153051265162, 3.6596267906380984, 1), actual 0\n", + "activation -111.117664731\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.443170896641262, 9.351637036828835, 1), actual 0\n", + "activation -7.4221549135\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.3987984768476194, 6.039436692979809, 1), actual 1\n", + "activation 79.4836173662\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.507374437231959, 2.8942089149396413, 1), actual 0\n", + "activation -127.718145428\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.9935925736468505, 5.270584030180434, 1), actual 0\n", + "activation -133.368685859\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.641925533937323, 6.090415031406695, 1), actual 0\n", + "activation -165.506500236\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.6154114349885442, 3.2139162654620854, 1), actual 1\n", + "activation 33.4671887732\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.1647757502712945, 5.65257882633725, 1), actual 1\n", + "activation 0.441768488299\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3072146878925337, 1.0590975460143037, 1), actual 0\n", + "activation -42.2090789602\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.192802215060135, 3.9361834633946446, 1), actual 0\n", + "activation -157.676972583\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.905682319649161, 7.02684831070679, 1), actual 1\n", + "activation 26.9100404344\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.722727452641504, 5.446057740436029, 1), actual 0\n", + "activation -97.084244887\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.672673354327543, 3.946823625401171, 1), actual 1\n", + "activation 15.8037365482\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.1455617252542005, 3.8130568965414735, 1), actual 0\n", + "activation -131.591761376\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.093258189224112, 5.108882558244428, 1), actual 0\n", + "activation -138.322090967\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.46967309343628, 9.666354617521636, 1), actual 0\n", + "activation -83.3936613714\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.8196945752536577, 5.205272887963199, 1), actual 1\n", + "activation 56.4094664364\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.905682319649161, 7.02684831070679, 1), actual 1\n", + "activation 26.9100404344\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.596006325563363, 0.20601525116155095, 1), actual 0\n", + "activation -115.208343524\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.606562632219457, 1.636997760425708, 1), actual 0\n", + "activation -201.435084025\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.2837742452819025, 1.7037136285723686, 1), actual 0\n", + "activation -85.5688333362\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.4084822494885856, 3.341158023148373, 1), actual 0\n", + "activation -38.9700075868\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.15663629270499, 2.2715570393710327, 1), actual 0\n", + "activation -207.016863859\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.09874190336673583, 6.382227853095017, 1), actual 1\n", + "activation 92.3443228091\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.68514293424815, 2.663703689110534, 1), actual 0\n", + "activation -55.9770496539\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.672673354327543, 3.946823625401171, 1), actual 1\n", + "activation 15.8037365482\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.710739229023136, 0.9315734142648702, 1), actual 0\n", + "activation -161.087991858\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.1119575789514045, 1.7229145080093333, 1), actual 0\n", + "activation -107.311430925\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.5448938985282936, 7.797834020938884, 1), actual 1\n", + "activation 100.653532101\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.908942264364572, 7.697005742911313, 1), actual 1\n", + "activation 9.78809827574\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.927844286434178, 3.28726991476319, 1), actual 0\n", + "activation -186.462835465\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.8196945752536577, 5.205272887963199, 1), actual 1\n", + "activation 56.4094664364\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.9806349519394395, 9.031509800204056, 1), actual 1\n", + "activation 0.31258140923\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.401406238607672, 8.470493640496457, 1), actual 1\n", + "activation 60.8846408913\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.496843709612131, 4.5641606813826066, 1), actual 0\n", + "activation -156.812089999\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.293153051265162, 3.6596267906380984, 1), actual 0\n", + "activation -111.117664731\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.03580069578259, 8.4661693659913, 1), actual 1\n", + "activation 43.9584806862\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.192802215060135, 3.9361834633946446, 1), actual 0\n", + "activation -157.676972583\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.61739680709439, 6.117839361458811, 1), actual 0\n", + "activation -4.96153214837\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.905682319649161, 7.02684831070679, 1), actual 1\n", + "activation 26.9100404344\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.68514293424815, 2.663703689110534, 1), actual 0\n", + "activation -55.9770496539\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.9983266598478, 1.8640958741769331, 1), actual 0\n", + "activation -128.862840844\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.43628818342939, 6.982136553712499, 1), actual 0\n", + "activation -14.416170653\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.2315888872941105, 1.9882133320366713, 1), actual 0\n", + "activation -159.8790787\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.818427898726406, 0.06597202102547328, 1), actual 0\n", + "activation -176.28385568\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.270048303565226, 4.145168925603738, 1), actual 0\n", + "activation -130.16913742\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.6768250252013868, 6.994872275079214, 1), actual 1\n", + "activation 32.538317611\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.917163743267875, 6.542643315036429, 1), actual 0\n", + "activation -6.87783163557\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.8295593621772364, 6.46588813346654, 1), actual 1\n", + "activation 20.9411010616\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.917163743267875, 6.542643315036429, 1), actual 0\n", + "activation -6.87783163557\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.631450050859798, 1.9500588767296667, 1), actual 0\n", + "activation -64.7177161425\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.8295593621772364, 6.46588813346654, 1), actual 1\n", + "activation 20.9411010616\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.722727452641504, 5.446057740436029, 1), actual 0\n", + "activation -97.084244887\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.181485178079948, 7.2791630783924095, 1), actual 0\n", + "activation -109.745301841\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.376558852812839, 3.8996371469160795, 1), actual 0\n", + "activation -83.3315343506\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.585454104080487, 9.497175946383228, 1), actual 1\n", + "activation 97.2038468411\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9168198401195615, 2.3879060556407095, 1), actual 1\n", + "activation 13.6856346147\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.61739680709439, 6.117839361458811, 1), actual 0\n", + "activation -4.96153214837\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.9745285630306793, 9.699005654934675, 1), actual 1\n", + "activation 36.5690960248\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.9983266598478, 1.8640958741769331, 1), actual 0\n", + "activation -128.862840844\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.905682319649161, 7.02684831070679, 1), actual 1\n", + "activation 26.9100404344\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9168198401195615, 2.3879060556407095, 1), actual 1\n", + "activation 13.6856346147\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.192802215060135, 3.9361834633946446, 1), actual 0\n", + "activation -157.676972583\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.15663629270499, 2.2715570393710327, 1), actual 0\n", + "activation -207.016863859\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.61739680709439, 6.117839361458811, 1), actual 0\n", + "activation -4.96153214837\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.860449470981059, 8.414673599175096, 1), actual 0\n", + "activation -5.28113573775\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.8295593621772364, 6.46588813346654, 1), actual 1\n", + "activation 20.9411010616\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.631450050859798, 1.9500588767296667, 1), actual 0\n", + "activation -64.7177161425\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.690978851317402, 6.943999836625558, 1), actual 0\n", + "activation -74.8975490584\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.6154114349885442, 3.2139162654620854, 1), actual 1\n", + "activation 33.4671887732\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.05745539735547811, 9.527934518916851, 1), actual 1\n", + "activation 138.261944889\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.585454104080487, 9.497175946383228, 1), actual 1\n", + "activation 97.2038468411\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.905682319649161, 7.02684831070679, 1), actual 1\n", + "activation 26.9100404344\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9168198401195615, 2.3879060556407095, 1), actual 1\n", + "activation 13.6856346147\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.596006325563363, 0.20601525116155095, 1), actual 0\n", + "activation -115.208343524\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.24631434468817104, 5.173384257803269, 1), actual 1\n", + "activation 71.1976811438\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.908942264364572, 7.697005742911313, 1), actual 1\n", + "activation 9.78809827574\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.508752995382578, 5.336332860186444, 1), actual 0\n", + "activation -92.9593751615\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.4355430271620131, 4.417792135688179, 1), actual 1\n", + "activation 55.4015962981\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.4714453635180336, 6.047354839769432, 1), actual 1\n", + "activation 24.4978254341\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.710739229023136, 0.9315734142648702, 1), actual 0\n", + "activation -161.087991858\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.585454104080487, 9.497175946383228, 1), actual 1\n", + "activation 97.2038468411\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.181485178079948, 7.2791630783924095, 1), actual 0\n", + "activation -109.745301841\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.8295593621772364, 6.46588813346654, 1), actual 1\n", + "activation 20.9411010616\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.518311571730163, 6.768531398973953, 1), actual 0\n", + "activation -152.558572687\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.727355694553044, 0.3776260800598663, 1), actual 0\n", + "activation -196.006062161\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.68514293424815, 2.663703689110534, 1), actual 0\n", + "activation -55.9770496539\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.6154114349885442, 3.2139162654620854, 1), actual 1\n", + "activation 33.4671887732\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.601602387823329, 0.3227673378964113, 1), actual 0\n", + "activation -113.693622102\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.5448938985282936, 7.797834020938884, 1), actual 1\n", + "activation 100.653532101\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.2315888872941105, 1.9882133320366713, 1), actual 0\n", + "activation -159.8790787\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.606562632219457, 1.636997760425708, 1), actual 0\n", + "activation -201.435084025\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.690978851317402, 6.943999836625558, 1), actual 0\n", + "activation -74.8975490584\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.672673354327543, 3.946823625401171, 1), actual 1\n", + "activation 15.8037365482\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.7200789393907734, 5.496880819540703, 1), actual 1\n", + "activation 36.6287584102\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.641925533937323, 6.090415031406695, 1), actual 0\n", + "activation -165.506500236\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.6154114349885442, 3.2139162654620854, 1), actual 1\n", + "activation 33.4671887732\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.8196945752536577, 5.205272887963199, 1), actual 1\n", + "activation 56.4094664364\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.818427898726406, 0.06597202102547328, 1), actual 0\n", + "activation -176.28385568\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.601602387823329, 0.3227673378964113, 1), actual 0\n", + "activation -113.693622102\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.905682319649161, 7.02684831070679, 1), actual 1\n", + "activation 26.9100404344\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.68514293424815, 2.663703689110534, 1), actual 0\n", + "activation -55.9770496539\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.03580069578259, 8.4661693659913, 1), actual 1\n", + "activation 43.9584806862\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.722727452641504, 5.446057740436029, 1), actual 0\n", + "activation -97.084244887\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.690978851317402, 6.943999836625558, 1), actual 0\n", + "activation -74.8975490584\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.601602387823329, 0.3227673378964113, 1), actual 0\n", + "activation -113.693622102\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.2315888872941105, 1.9882133320366713, 1), actual 0\n", + "activation -159.8790787\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.9745285630306793, 9.699005654934675, 1), actual 1\n", + "activation 36.5690960248\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.05745539735547811, 9.527934518916851, 1), actual 1\n", + "activation 138.261944889\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.653076221592844, 1.3467164503467732, 1), actual 0\n", + "activation -127.056438517\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.492335903506584, 2.2501467996671174, 1), actual 0\n", + "activation -216.246052864\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.079649661953283, 6.659229487453656, 1), actual 0\n", + "activation -89.2872668747\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.270048303565226, 4.145168925603738, 1), actual 0\n", + "activation -130.16913742\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.4084822494885856, 3.341158023148373, 1), actual 0\n", + "activation -38.9700075868\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.653076221592844, 1.3467164503467732, 1), actual 0\n", + "activation -127.056438517\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.9806349519394395, 9.031509800204056, 1), actual 1\n", + "activation 0.31258140923\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.376558852812839, 3.8996371469160795, 1), actual 0\n", + "activation -83.3315343506\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.585454104080487, 9.497175946383228, 1), actual 1\n", + "activation 97.2038468411\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.376558852812839, 3.8996371469160795, 1), actual 0\n", + "activation -83.3315343506\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3962070188044935, 5.021835204430203, 1), actual 1\n", + "activation 11.8863198818\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.46967309343628, 9.666354617521636, 1), actual 0\n", + "activation -83.3936613714\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.61739680709439, 6.117839361458811, 1), actual 0\n", + "activation -4.96153214837\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.293153051265162, 3.6596267906380984, 1), actual 0\n", + "activation -111.117664731\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.9309630662921906, 8.560278192120636, 1), actual 1\n", + "activation 48.086316029\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.451583403119836, 0.6826521158120202, 1), actual 0\n", + "activation -24.8268389964\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.43628818342939, 6.982136553712499, 1), actual 0\n", + "activation -14.416170653\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.860449470981059, 8.414673599175096, 1), actual 0\n", + "activation -5.28113573775\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.8196945752536577, 5.205272887963199, 1), actual 1\n", + "activation 56.4094664364\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9856181286237742, 0.664054386459394, 1), actual 0\n", + "activation -12.7047416229\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.022792551671591, 8.963715479050858, 1), actual 0\n", + "activation -81.5251386157\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.270048303565226, 4.145168925603738, 1), actual 0\n", + "activation -130.16913742\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.3609042458766931, 7.858509647839078, 1), actual 1\n", + "activation 106.409163868\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.1119575789514045, 1.7229145080093333, 1), actual 0\n", + "activation -107.311430925\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.818427898726406, 0.06597202102547328, 1), actual 0\n", + "activation -176.28385568\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.727355694553044, 0.3776260800598663, 1), actual 0\n", + "activation -196.006062161\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.1119575789514045, 1.7229145080093333, 1), actual 0\n", + "activation -107.311430925\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.4256695234516705, 0.3391835724830805, 1), actual 0\n", + "activation -135.366471603\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.451583403119836, 0.6826521158120202, 1), actual 0\n", + "activation -24.8268389964\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.15663629270499, 2.2715570393710327, 1), actual 0\n", + "activation -207.016863859\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.9806349519394395, 9.031509800204056, 1), actual 1\n", + "activation 0.31258140923\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3130320726271547, 3.866038256369144, 1), actual 1\n", + "activation -2.37039453232\n", + "predicted 0, error 1\n", + "Updating weight 0 by 2.3130320726271547\n", + "Updating weight 1 by 3.866038256369144\n", + "Updating weight 2 by 1\n", + "example (1.910197726504086, 2.663137790168496, 1), actual 0\n", + "activation 6.91362817692\n", + "predicted 1, error -1\n", + "Updating weight 0 by -1.910197726504086\n", + "Updating weight 1 by -2.663137790168496\n", + "Updating weight 2 by -1\n", + "example (2.3962070188044935, 5.021835204430203, 1), actual 1\n", + "activation 18.892362278\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.651268612790532, 6.972322990079941, 1), actual 1\n", + "activation 94.7131700747\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.620754472047351, 6.259532682231028, 1), actual 0\n", + "activation -72.5863615506\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.2315888872941105, 1.9882133320366713, 1), actual 0\n", + "activation -154.574323575\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.9745285630306793, 9.699005654934675, 1), actual 1\n", + "activation 49.8371110636\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.518311571730163, 6.768531398973953, 1), actual 0\n", + "activation -140.582400293\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3819906463580685, 6.783367960516962, 1), actual 1\n", + "activation 46.4818519861\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.907198863790789, 8.325278744588815, 1), actual 0\n", + "activation -74.34891433\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.4714453635180336, 6.047354839769432, 1), actual 1\n", + "activation 32.7677744671\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.641925533937323, 6.090415031406695, 1), actual 0\n", + "activation -154.296238388\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.03580069578259, 8.4661693659913, 1), actual 1\n", + "activation 55.3653645518\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.741906198125639, 7.276494136007247, 1), actual 0\n", + "activation -112.406951406\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.09874190336673583, 6.382227853095017, 1), actual 1\n", + "activation 100.061284299\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.630182521583322, 2.6250709133395436, 1), actual 0\n", + "activation -207.531533604\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.46967309343628, 9.666354617521636, 1), actual 0\n", + "activation -68.354123673\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.727355694553044, 0.3776260800598663, 1), actual 0\n", + "activation -192.438971295\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9168198401195615, 2.3879060556407095, 1), actual 1\n", + "activation 16.9273744431\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.875266984278501, 4.490679281547934, 1), actual 0\n", + "activation -54.2184028009\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.508752995382578, 5.336332860186444, 1), actual 0\n", + "activation -83.9183486192\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.875266984278501, 4.490679281547934, 1), actual 0\n", + "activation -54.2184028009\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.093258189224112, 5.108882558244428, 1), actual 0\n", + "activation -128.916371385\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.9806349519394395, 9.031509800204056, 1), actual 1\n", + "activation 13.1829595825\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.4256695234516705, 0.3391835724830805, 1), actual 0\n", + "activation -132.77282149\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.585454104080487, 9.497175946383228, 1), actual 1\n", + "activation 109.266679582\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.496843709612131, 4.5641606813826066, 1), actual 0\n", + "activation -147.899038508\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.620754472047351, 6.259532682231028, 1), actual 0\n", + "activation -72.5863615506\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.365921435638924, 1.7665655545978187, 1), actual 0\n", + "activation -82.9733482851\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.860449470981059, 8.414673599175096, 1), actual 0\n", + "activation 6.79883504213\n", + "predicted 1, error -1\n", + "Updating weight 0 by -4.860449470981059\n", + "Updating weight 1 by -8.414673599175096\n", + "Updating weight 2 by -1\n", + "example (0.8196945752536577, 5.205272887963199, 1), actual 1\n", + "activation 14.2163363368\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.651268612790532, 6.972322990079941, 1), actual 1\n", + "activation 31.8778897006\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.641925533937323, 6.090415031406695, 1), actual 0\n", + "activation -253.409184821\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.181485178079948, 7.2791630783924095, 1), actual 0\n", + "activation -199.710886634\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.727355694553044, 0.3776260800598663, 1), actual 0\n", + "activation -234.174993399\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.376558852812839, 3.8996371469160795, 1), actual 0\n", + "activation -136.421462817\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.61739680709439, 6.117839361458811, 1), actual 0\n", + "activation -66.2069644071\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.706875996441108, 9.923714046947334, 1), actual 0\n", + "activation -228.453314994\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.620754472047351, 6.259532682231028, 1), actual 0\n", + "activation -158.438128526\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.079649661953283, 6.659229487453656, 1), actual 0\n", + "activation -169.87047259\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.8295593621772364, 6.46588813346654, 1), actual 1\n", + "activation -39.3025038697\n", + "predicted 0, error 1\n", + "Updating weight 0 by 2.8295593621772364\n", + "Updating weight 1 by 6.46588813346654\n", + "Updating weight 2 by 1\n", + "example (0.3987984768476194, 6.039436692979809, 1), actual 1\n", + "activation 74.329625973\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.741906198125639, 7.276494136007247, 1), actual 0\n", + "activation -144.34112825\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3819906463580685, 6.783367960516962, 1), actual 1\n", + "activation 28.4249618532\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.0930283200245614, 2.025801906750686, 1), actual 0\n", + "activation -27.6601784834\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3072146878925337, 1.0590975460143037, 1), actual 0\n", + "activation -46.7553181012\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.4256695234516705, 0.3391835724830805, 1), actual 0\n", + "activation -144.452756075\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.079649661953283, 6.659229487453656, 1), actual 0\n", + "activation -105.780350688\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.3609042458766931, 7.858509647839078, 1), actual 1\n", + "activation 99.9600471659\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.46967309343628, 9.666354617521636, 1), actual 0\n", + "activation -104.392750368\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.411668814146135, 4.035197667686209, 1), actual 0\n", + "activation -37.7302117952\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.2315888872941105, 1.9882133320366713, 1), actual 0\n", + "activation -173.135487162\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.4649859681336621, 9.011384396969206, 1), actual 1\n", + "activation 112.589983888\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.741906198125639, 7.276494136007247, 1), actual 0\n", + "activation -144.34112825\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.61739680709439, 6.117839361458811, 1), actual 0\n", + "activation -15.4140604752\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.9745285630306793, 9.699005654934675, 1), actual 1\n", + "activation 22.8639990656\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.2837742452819025, 1.7037136285723686, 1), actual 0\n", + "activation -93.8138311212\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.910197726504086, 2.663137790168496, 1), actual 0\n", + "activation -13.8968159541\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.620754472047351, 6.259532682231028, 1), actual 0\n", + "activation -98.2308726339\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.365921435638924, 1.7665655545978187, 1), actual 0\n", + "activation -95.2827122216\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.0511694684247652, 3.068483285849682, 1), actual 1\n", + "activation 15.8109013529\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.0930283200245614, 2.025801906750686, 1), actual 0\n", + "activation -27.6601784834\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.6154114349885442, 3.2139162654620854, 1), actual 1\n", + "activation 30.0680527079\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.68514293424815, 2.663703689110534, 1), actual 0\n", + "activation -63.9634844692\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.4714453635180336, 6.047354839769432, 1), actual 1\n", + "activation 15.9635433062\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.9806349519394395, 9.031509800204056, 1), actual 1\n", + "activation -14.532637709\n", + "predicted 0, error 1\n", + "Updating weight 0 by 4.9806349519394395\n", + "Updating weight 1 by 9.031509800204056\n", + "Updating weight 2 by 1\n", + "example (2.8295593621772364, 6.46588813346654, 1), actual 1\n", + "activation 85.0013459711\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.9309630662921906, 8.560278192120636, 1), actual 1\n", + "activation 129.839855099\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.6104017774044366, 3.774113993604651, 1), actual 1\n", + "activation 52.6682677195\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.05745539735547811, 9.527934518916851, 1), actual 1\n", + "activation 218.399459208\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.507374437231959, 2.8942089149396413, 1), actual 0\n", + "activation -80.9213281494\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.507374437231959, 2.8942089149396413, 1), actual 0\n", + "activation -80.9213281494\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.03580069578259, 8.4661693659913, 1), actual 1\n", + "activation 125.283745787\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.0511694684247652, 3.068483285849682, 1), actual 1\n", + "activation 49.7594296156\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.3279565582768065, 7.106134092027016, 1), actual 0\n", + "activation 41.3878663409\n", + "predicted 1, error -1\n", + "Updating weight 0 by -5.3279565582768065\n", + "Updating weight 1 by -7.106134092027016\n", + "Updating weight 2 by -1\n", + "example (0.651268612790532, 6.972322990079941, 1), actual 1\n", + "activation 93.0010950394\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.706875996441108, 9.923714046947334, 1), actual 0\n", + "activation -120.086038047\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3130320726271547, 3.866038256369144, 1), actual 1\n", + "activation -2.37954953965\n", + "predicted 0, error 1\n", + "Updating weight 0 by 2.3130320726271547\n", + "Updating weight 1 by 3.866038256369144\n", + "Updating weight 2 by 1\n", + "example (0.5448938985282936, 7.797834020938884, 1), actual 1\n", + "activation 141.181715506\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.672673354327543, 3.946823625401171, 1), actual 1\n", + "activation 37.2823354958\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.022792551671591, 8.963715479050858, 1), actual 0\n", + "activation -32.5895188907\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3130320726271547, 3.866038256369144, 1), actual 1\n", + "activation 18.9168196291\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.596006325563363, 0.20601525116155095, 1), actual 0\n", + "activation -111.617024454\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.451583403119836, 0.6826521158120202, 1), actual 0\n", + "activation -19.8923640093\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.6768250252013868, 6.994872275079214, 1), actual 1\n", + "activation 69.7349908422\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.6104017774044366, 3.774113993604651, 1), actual 1\n", + "activation 35.5845369351\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.9745285630306793, 9.699005654934675, 1), actual 1\n", + "activation 87.8477282528\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.7152810487220673, 5.142636385860659, 1), actual 1\n", + "activation 85.4815566953\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.908942264364572, 7.697005742911313, 1), actual 1\n", + "activation 50.9434364374\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.15663629270499, 2.2715570393710327, 1), actual 0\n", + "activation -191.463875707\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.620754472047351, 6.259532682231028, 1), actual 0\n", + "activation -47.9648412861\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.651268612790532, 6.972322990079941, 1), actual 1\n", + "activation 122.462767644\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.4649859681336621, 9.011384396969206, 1), actual 1\n", + "activation 166.692669109\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.68514293424815, 2.663703689110534, 1), actual 0\n", + "activation -40.292949691\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.9935925736468505, 5.270584030180434, 1), actual 0\n", + "activation -103.076727341\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.908942264364572, 7.697005742911313, 1), actual 1\n", + "activation 50.9434364374\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.496843709612131, 4.5641606813826066, 1), actual 0\n", + "activation -129.914485836\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.860449470981059, 8.414673599175096, 1), actual 0\n", + "activation 39.8164972638\n", + "predicted 1, error -1\n", + "Updating weight 0 by -4.860449470981059\n", + "Updating weight 1 by -8.414673599175096\n", + "Updating weight 2 by -1\n", + "example (8.46967309343628, 9.666354617521636, 1), actual 0\n", + "activation -154.267601311\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.508752995382578, 5.336332860186444, 1), actual 0\n", + "activation -140.376006373\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.860449470981059, 8.414673599175096, 1), actual 0\n", + "activation -55.6142035769\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.690978851317402, 6.943999836625558, 1), actual 0\n", + "activation -128.554812985\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.907198863790789, 8.325278744588815, 1), actual 0\n", + "activation -151.360393153\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.2315888872941105, 1.9882133320366713, 1), actual 0\n", + "activation -199.284649358\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.690978851317402, 6.943999836625558, 1), actual 0\n", + "activation -128.554812985\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.653076221592844, 1.3467164503467732, 1), actual 0\n", + "activation -157.161424574\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3072146878925337, 1.0590975460143037, 1), actual 0\n", + "activation -56.212390292\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.8196945752536577, 5.205272887963199, 1), actual 1\n", + "activation 35.1648388809\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9856181286237742, 0.664054386459394, 1), actual 0\n", + "activation -19.3997854106\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.508752995382578, 5.336332860186444, 1), actual 0\n", + "activation -140.376006373\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.507374437231959, 2.8942089149396413, 1), actual 0\n", + "activation -166.900672918\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.631450050859798, 1.9500588767296667, 1), actual 0\n", + "activation -87.7120498313\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.443170896641262, 9.351637036828835, 1), actual 0\n", + "activation -63.5475175058\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.4064504169290135, 2.663941543391748, 1), actual 0\n", + "activation -197.372818208\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9856181286237742, 0.664054386459394, 1), actual 0\n", + "activation -19.3997854106\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.601602387823329, 0.3227673378964113, 1), actual 0\n", + "activation -135.593175147\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3819906463580685, 6.783367960516962, 1), actual 1\n", + "activation 3.73518526268\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.908942264364572, 7.697005742911313, 1), actual 1\n", + "activation -33.8235709411\n", + "predicted 0, error 1\n", + "Updating weight 0 by 3.908942264364572\n", + "Updating weight 1 by 7.697005742911313\n", + "Updating weight 2 by 1\n", + "example (5.18767455738911, 9.398469126153845, 1), actual 1\n", + "activation 38.5279477784\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.450406859792585, 1.4683907453208889, 1), actual 0\n", + "activation -88.7283297551\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9856181286237742, 0.664054386459394, 1), actual 0\n", + "activation -9.4358306249\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9168198401195615, 2.3879060556407095, 1), actual 1\n", + "activation 24.4573682106\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.61739680709439, 6.117839361458811, 1), actual 0\n", + "activation 20.2950788094\n", + "predicted 1, error -1\n", + "Updating weight 0 by -3.61739680709439\n", + "Updating weight 1 by -6.117839361458811\n", + "Updating weight 2 by -1\n", + "example (8.181485178079948, 7.2791630783924095, 1), actual 0\n", + "activation -157.392748965\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3130320726271547, 3.866038256369144, 1), actual 1\n", + "activation -19.0775342968\n", + "predicted 0, error 1\n", + "Updating weight 0 by 2.3130320726271547\n", + "Updating weight 1 by 3.866038256369144\n", + "Updating weight 2 by 1\n", + "example (5.653076221592844, 1.3467164503467732, 1), actual 0\n", + "activation -134.104402611\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.46967309343628, 9.666354617521636, 1), actual 0\n", + "activation -78.5724020921\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.18767455738911, 9.398469126153845, 1), actual 1\n", + "activation 10.5978448674\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.651268612790532, 6.972322990079941, 1), actual 1\n", + "activation 100.289492347\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.507374437231959, 2.8942089149396413, 1), actual 0\n", + "activation -133.192151874\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.4355430271620131, 4.417792135688179, 1), actual 1\n", + "activation 64.7377317133\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3962070188044935, 5.021835204430203, 1), actual 1\n", + "activation 18.7155054868\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.508752995382578, 5.336332860186444, 1), actual 0\n", + "activation -93.3660301343\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.293153051265162, 3.6596267906380984, 1), actual 0\n", + "activation -114.591694583\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.630182521583322, 2.6250709133395436, 1), actual 0\n", + "activation -226.591578292\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.429595407669325, 2.1741339470916223, 1), actual 0\n", + "activation -199.733680046\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.365921435638924, 1.7665655545978187, 1), actual 0\n", + "activation -90.5643835846\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.917163743267875, 6.542643315036429, 1), actual 0\n", + "activation 0.191117454803\n", + "predicted 1, error -1\n", + "Updating weight 0 by -3.917163743267875\n", + "Updating weight 1 by -6.542643315036429\n", + "Updating weight 2 by -1\n", + "example (7.907198863790789, 8.325278744588815, 1), actual 0\n", + "activation -170.875756261\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.710739229023136, 0.9315734142648702, 1), actual 0\n", + "activation -204.408662188\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.0511694684247652, 3.068483285849682, 1), actual 1\n", + "activation -0.0286110416634\n", + "predicted 0, error 1\n", + "Updating weight 0 by 1.0511694684247652\n", + "Updating weight 1 by 3.068483285849682\n", + "Updating weight 2 by 1\n", + "example (5.1119575789514045, 1.7229145080093333, 1), actual 0\n", + "activation -133.176924042\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.518311571730163, 6.768531398973953, 1), actual 0\n", + "activation -206.559272407\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.4084822494885856, 3.341158023148373, 1), actual 0\n", + "activation -58.9481807217\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.24631434468817104, 5.173384257803269, 1), actual 1\n", + "activation 63.7863525575\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.18767455738911, 9.398469126153845, 1), actual 1\n", + "activation -36.9217864875\n", + "predicted 0, error 1\n", + "Updating weight 0 by 5.18767455738911\n", + "Updating weight 1 by 9.398469126153845\n", + "Updating weight 2 by 1\n", + "example (2.3072146878925337, 1.0590975460143037, 1), actual 0\n", + "activation -30.8050318149\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.875266984278501, 4.490679281547934, 1), actual 0\n", + "activation -21.690086162\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.3609042458766931, 7.858509647839078, 1), actual 1\n", + "activation 171.425753158\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.8196945752536577, 5.205272887963199, 1), actual 1\n", + "activation 100.384287279\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.727355694553044, 0.3776260800598663, 1), actual 0\n", + "activation -187.86721168\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3130320726271547, 3.866038256369144, 1), actual 1\n", + "activation 31.4925614392\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.927844286434178, 3.28726991476319, 1), actual 0\n", + "activation -154.561407572\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.376558852812839, 3.8996371469160795, 1), actual 0\n", + "activation -47.9637550099\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.7200789393907734, 5.496880819540703, 1), actual 1\n", + "activation 83.2998221555\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.181485178079948, 7.2791630783924095, 1), actual 0\n", + "activation -46.208383547\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.2837742452819025, 1.7037136285723686, 1), actual 0\n", + "activation -68.2101508644\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.4084822494885856, 3.341158023148373, 1), actual 0\n", + "activation -8.86431355053\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3962070188044935, 5.021835204430203, 1), actual 1\n", + "activation 55.0296360603\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.653076221592844, 1.3467164503467732, 1), actual 0\n", + "activation -112.001402494\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.022792551671591, 8.963715479050858, 1), actual 0\n", + "activation -4.57520595724\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.365921435638924, 1.7665655545978187, 1), actual 0\n", + "activation -68.9624294868\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.401406238607672, 8.470493640496457, 1), actual 1\n", + "activation 131.620595153\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.429595407669325, 2.1741339470916223, 1), actual 0\n", + "activation -166.282613078\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.05745539735547811, 9.527934518916851, 1), actual 1\n", + "activation 216.512118937\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3819906463580685, 6.783367960516962, 1), actual 1\n", + "activation 94.5930804887\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.585454104080487, 9.497175946383228, 1), actual 1\n", + "activation 175.824431967\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.3279565582768065, 7.106134092027016, 1), actual 0\n", + "activation 24.6480383844\n", + "predicted 1, error -1\n", + "Updating weight 0 by -5.3279565582768065\n", + "Updating weight 1 by -7.106134092027016\n", + "Updating weight 2 by -1\n", + "example (7.448079300022808, 3.103095683918884, 1), actual 0\n", + "activation -182.652454966\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.764445713683653, 1.424649425018134, 1), actual 0\n", + "activation -281.052413455\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.4064504169290135, 2.663941543391748, 1), actual 0\n", + "activation -187.990585906\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.764445713683653, 1.424649425018134, 1), actual 0\n", + "activation -281.052413455\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.9935925736468505, 5.270584030180434, 1), actual 0\n", + "activation -167.019939879\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.4084822494885856, 3.341158023148373, 1), actual 0\n", + "activation -51.7672758406\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.496843709612131, 4.5641606813826066, 1), actual 0\n", + "activation -193.573309464\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3072146878925337, 1.0590975460143037, 1), actual 0\n", + "activation -51.6238606211\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.46967309343628, 9.666354617521636, 1), actual 0\n", + "activation -115.458518874\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.443170896641262, 9.351637036828835, 1), actual 0\n", + "activation -24.864453459\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.875266984278501, 4.490679281547934, 1), actual 0\n", + "activation -80.5766660032\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.9272066167158133, 1.9791743425547825, 1), actual 1\n", + "activation 5.78972436056\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.492335903506584, 2.2501467996671174, 1), actual 0\n", + "activation -259.978839404\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.875266984278501, 4.490679281547934, 1), actual 0\n", + "activation -80.5766660032\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.518311571730163, 6.768531398973953, 1), actual 0\n", + "activation -192.378778544\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.927844286434178, 3.28726991476319, 1), actual 0\n", + "activation -226.4883549\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.653076221592844, 1.3467164503467732, 1), actual 0\n", + "activation -152.690694703\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.4714453635180336, 6.047354839769432, 1), actual 1\n", + "activation 18.7349651805\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.365921435638924, 1.7665655545978187, 1), actual 0\n", + "activation -105.777320946\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3072146878925337, 1.0590975460143037, 1), actual 0\n", + "activation -51.6238606211\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.606562632219457, 1.636997760425708, 1), actual 0\n", + "activation -241.354185172\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.518311571730163, 6.768531398973953, 1), actual 0\n", + "activation -192.378778544\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (7.270048303565226, 4.145168925603738, 1), actual 0\n", + "activation -161.263687962\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.7200789393907734, 5.496880819540703, 1), actual 1\n", + "activation 34.073744098\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.61739680709439, 6.117839361458811, 1), actual 0\n", + "activation -16.3045931254\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.908942264364572, 7.697005742911313, 1), actual 1\n", + "activation -1.57853055172\n", + "predicted 0, error 1\n", + "Updating weight 0 by 3.908942264364572\n", + "Updating weight 1 by 7.697005742911313\n", + "Updating weight 2 by 1\n", + "example (9.630182521583322, 2.6250709133395436, 1), actual 0\n", + "activation -199.795928589\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.451583403119836, 0.6826521158120202, 1), actual 0\n", + "activation -18.4361676577\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.496843709612131, 4.5641606813826066, 1), actual 0\n", + "activation -124.229266997\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.601602387823329, 0.3227673378964113, 1), actual 0\n", + "activation -113.593813247\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.3987984768476194, 6.039436692979809, 1), actual 1\n", + "activation 132.964871708\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.7152810487220673, 5.142636385860659, 1), actual 1\n", + "activation 103.747940569\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.690978851317402, 6.943999836625558, 1), actual 0\n", + "activation -20.0350066117\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (1.910197726504086, 2.663137790168496, 1), actual 0\n", + "activation 14.1392412148\n", + "predicted 1, error -1\n", + "Updating weight 0 by -1.910197726504086\n", + "Updating weight 1 by -2.663137790168496\n", + "Updating weight 2 by -1\n", + "example (1.6104017774044366, 3.774113993604651, 1), actual 1\n", + "activation 33.66008072\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.3987984768476194, 6.039436692979809, 1), actual 1\n", + "activation 115.119235676\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (3.68514293424815, 2.663703689110534, 1), actual 0\n", + "activation -49.9681430902\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.5448938985282936, 7.797834020938884, 1), actual 1\n", + "activation 146.285672287\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (8.181485178079948, 7.2791630783924095, 1), actual 0\n", + "activation -89.5306455164\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.401406238607672, 8.470493640496457, 1), actual 1\n", + "activation 105.072687484\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (6.507374437231959, 2.8942089149396413, 1), actual 0\n", + "activation -128.599921081\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.376558852812839, 3.8996371469160795, 1), actual 0\n", + "activation -74.9445453862\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.174597655432761, 6.050566632049054, 1), actual 0\n", + "activation -25.5873770383\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.691663780302689, 9.19692948638577, 1), actual 1\n", + "activation 111.164004192\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.3609042458766931, 7.858509647839078, 1), actual 1\n", + "activation 152.939302956\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.0930283200245614, 2.025801906750686, 1), actual 0\n", + "activation -15.8561095914\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.9309630662921906, 8.560278192120636, 1), actual 1\n", + "activation 91.2572643418\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (0.6154114349885442, 3.2139162654620854, 1), actual 1\n", + "activation 51.7190759287\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (9.492335903506584, 2.2501467996671174, 1), actual 0\n", + "activation -229.679143001\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (5.3279565582768065, 7.106134092027016, 1), actual 0\n", + "activation -8.81565969383\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.3130320726271547, 3.866038256369144, 1), actual 1\n", + "activation 14.7805270876\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (2.905682319649161, 7.02684831070679, 1), actual 1\n", + "activation 61.0646236448\n", + "predicted 1, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "example (4.2837742452819025, 1.7037136285723686, 1), actual 0\n", + "activation -87.002291638\n", + "predicted 0, error 0\n", + "Updating weight 0 by 0.0\n", + "Updating weight 1 by 0.0\n", + "Updating weight 2 by 0\n", + "Validation error: 0.0\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEACAYAAACj0I2EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nrkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAEACAYAAAC3adEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n08EmAgItyUIAAAAASUVORK5CYII=\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)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Fit the model\n", + "model.fit(X, Y, nb_epoch=150, batch_size=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 32/768 [>.............................] - ETA: 0sacc: 78.91%\n" + ] + } + ], + "source": [ + "\n", + "3\n", + "# evaluate the model\n", + "scores = model.evaluate(X, Y)\n", + "print(\"%s: %.2f%%\" % (model.metrics_names[1], scores[1]*100))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/projects/7-dnns/pima-indians-diabetes.csv b/projects/7-dnns/pima-indians-diabetes.csv new file mode 100644 index 0000000..982aab8 --- /dev/null +++ b/projects/7-dnns/pima-indians-diabetes.csv @@ -0,0 +1,768 @@ +6,148,72,35,0,33.6,0.627,50,1 +1,85,66,29,0,26.6,0.351,31,0 +8,183,64,0,0,23.3,0.672,32,1 +1,89,66,23,94,28.1,0.167,21,0 +0,137,40,35,168,43.1,2.288,33,1 +5,116,74,0,0,25.6,0.201,30,0 +3,78,50,32,88,31.0,0.248,26,1 +10,115,0,0,0,35.3,0.134,29,0 +2,197,70,45,543,30.5,0.158,53,1 +8,125,96,0,0,0.0,0.232,54,1 +4,110,92,0,0,37.6,0.191,30,0 +10,168,74,0,0,38.0,0.537,34,1 +10,139,80,0,0,27.1,1.441,57,0 +1,189,60,23,846,30.1,0.398,59,1 +5,166,72,19,175,25.8,0.587,51,1 +7,100,0,0,0,30.0,0.484,32,1 +0,118,84,47,230,45.8,0.551,31,1 +7,107,74,0,0,29.6,0.254,31,1 +1,103,30,38,83,43.3,0.183,33,0 +1,115,70,30,96,34.6,0.529,32,1 +3,126,88,41,235,39.3,0.704,27,0 +8,99,84,0,0,35.4,0.388,50,0 +7,196,90,0,0,39.8,0.451,41,1 +9,119,80,35,0,29.0,0.263,29,1 +11,143,94,33,146,36.6,0.254,51,1 +10,125,70,26,115,31.1,0.205,41,1 +7,147,76,0,0,39.4,0.257,43,1 +1,97,66,15,140,23.2,0.487,22,0 +13,145,82,19,110,22.2,0.245,57,0 +5,117,92,0,0,34.1,0.337,38,0 +5,109,75,26,0,36.0,0.546,60,0 +3,158,76,36,245,31.6,0.851,28,1 +3,88,58,11,54,24.8,0.267,22,0 +6,92,92,0,0,19.9,0.188,28,0 +10,122,78,31,0,27.6,0.512,45,0 +4,103,60,33,192,24.0,0.966,33,0 +11,138,76,0,0,33.2,0.420,35,0 +9,102,76,37,0,32.9,0.665,46,1 +2,90,68,42,0,38.2,0.503,27,1 +4,111,72,47,207,37.1,1.390,56,1 +3,180,64,25,70,34.0,0.271,26,0 +7,133,84,0,0,40.2,0.696,37,0 +7,106,92,18,0,22.7,0.235,48,0 +9,171,110,24,240,45.4,0.721,54,1 +7,159,64,0,0,27.4,0.294,40,0 +0,180,66,39,0,42.0,1.893,25,1 +1,146,56,0,0,29.7,0.564,29,0 +2,71,70,27,0,28.0,0.586,22,0 +7,103,66,32,0,39.1,0.344,31,1 +7,105,0,0,0,0.0,0.305,24,0 +1,103,80,11,82,19.4,0.491,22,0 +1,101,50,15,36,24.2,0.526,26,0 +5,88,66,21,23,24.4,0.342,30,0 +8,176,90,34,300,33.7,0.467,58,1 +7,150,66,42,342,34.7,0.718,42,0 +1,73,50,10,0,23.0,0.248,21,0 +7,187,68,39,304,37.7,0.254,41,1 +0,100,88,60,110,46.8,0.962,31,0 +0,146,82,0,0,40.5,1.781,44,0 +0,105,64,41,142,41.5,0.173,22,0 +2,84,0,0,0,0.0,0.304,21,0 +8,133,72,0,0,32.9,0.270,39,1 +5,44,62,0,0,25.0,0.587,36,0 +2,141,58,34,128,25.4,0.699,24,0 +7,114,66,0,0,32.8,0.258,42,1 +5,99,74,27,0,29.0,0.203,32,0 +0,109,88,30,0,32.5,0.855,38,1 +2,109,92,0,0,42.7,0.845,54,0 +1,95,66,13,38,19.6,0.334,25,0 +4,146,85,27,100,28.9,0.189,27,0 +2,100,66,20,90,32.9,0.867,28,1 +5,139,64,35,140,28.6,0.411,26,0 +13,126,90,0,0,43.4,0.583,42,1 +4,129,86,20,270,35.1,0.231,23,0 +1,79,75,30,0,32.0,0.396,22,0 +1,0,48,20,0,24.7,0.140,22,0 +7,62,78,0,0,32.6,0.391,41,0 +5,95,72,33,0,37.7,0.370,27,0 +0,131,0,0,0,43.2,0.270,26,1 +2,112,66,22,0,25.0,0.307,24,0 +3,113,44,13,0,22.4,0.140,22,0 +2,74,0,0,0,0.0,0.102,22,0 +7,83,78,26,71,29.3,0.767,36,0 +0,101,65,28,0,24.6,0.237,22,0 +5,137,108,0,0,48.8,0.227,37,1 +2,110,74,29,125,32.4,0.698,27,0 +13,106,72,54,0,36.6,0.178,45,0 +2,100,68,25,71,38.5,0.324,26,0 +15,136,70,32,110,37.1,0.153,43,1 +1,107,68,19,0,26.5,0.165,24,0 +1,80,55,0,0,19.1,0.258,21,0 +4,123,80,15,176,32.0,0.443,34,0 +7,81,78,40,48,46.7,0.261,42,0 +4,134,72,0,0,23.8,0.277,60,1 +2,142,82,18,64,24.7,0.761,21,0 +6,144,72,27,228,33.9,0.255,40,0 +2,92,62,28,0,31.6,0.130,24,0 +1,71,48,18,76,20.4,0.323,22,0 +6,93,50,30,64,28.7,0.356,23,0 +1,122,90,51,220,49.7,0.325,31,1 +1,163,72,0,0,39.0,1.222,33,1 +1,151,60,0,0,26.1,0.179,22,0 +0,125,96,0,0,22.5,0.262,21,0 +1,81,72,18,40,26.6,0.283,24,0 +2,85,65,0,0,39.6,0.930,27,0 +1,126,56,29,152,28.7,0.801,21,0 +1,96,122,0,0,22.4,0.207,27,0 +4,144,58,28,140,29.5,0.287,37,0 +3,83,58,31,18,34.3,0.336,25,0 +0,95,85,25,36,37.4,0.247,24,1 +3,171,72,33,135,33.3,0.199,24,1 +8,155,62,26,495,34.0,0.543,46,1 +1,89,76,34,37,31.2,0.192,23,0 +4,76,62,0,0,34.0,0.391,25,0 +7,160,54,32,175,30.5,0.588,39,1 +4,146,92,0,0,31.2,0.539,61,1 +5,124,74,0,0,34.0,0.220,38,1 +5,78,48,0,0,33.7,0.654,25,0 +4,97,60,23,0,28.2,0.443,22,0 +4,99,76,15,51,23.2,0.223,21,0 +0,162,76,56,100,53.2,0.759,25,1 +6,111,64,39,0,34.2,0.260,24,0 +2,107,74,30,100,33.6,0.404,23,0 +5,132,80,0,0,26.8,0.186,69,0 +0,113,76,0,0,33.3,0.278,23,1 +1,88,30,42,99,55.0,0.496,26,1 +3,120,70,30,135,42.9,0.452,30,0 +1,118,58,36,94,33.3,0.261,23,0 +1,117,88,24,145,34.5,0.403,40,1 +0,105,84,0,0,27.9,0.741,62,1 +4,173,70,14,168,29.7,0.361,33,1 +9,122,56,0,0,33.3,1.114,33,1 +3,170,64,37,225,34.5,0.356,30,1 +8,84,74,31,0,38.3,0.457,39,0 +2,96,68,13,49,21.1,0.647,26,0 +2,125,60,20,140,33.8,0.088,31,0 +0,100,70,26,50,30.8,0.597,21,0 +0,93,60,25,92,28.7,0.532,22,0 +0,129,80,0,0,31.2,0.703,29,0 +5,105,72,29,325,36.9,0.159,28,0 +3,128,78,0,0,21.1,0.268,55,0 +5,106,82,30,0,39.5,0.286,38,0 +2,108,52,26,63,32.5,0.318,22,0 +10,108,66,0,0,32.4,0.272,42,1 +4,154,62,31,284,32.8,0.237,23,0 +0,102,75,23,0,0.0,0.572,21,0 +9,57,80,37,0,32.8,0.096,41,0 +2,106,64,35,119,30.5,1.400,34,0 +5,147,78,0,0,33.7,0.218,65,0 +2,90,70,17,0,27.3,0.085,22,0 +1,136,74,50,204,37.4,0.399,24,0 +4,114,65,0,0,21.9,0.432,37,0 +9,156,86,28,155,34.3,1.189,42,1 +1,153,82,42,485,40.6,0.687,23,0 +8,188,78,0,0,47.9,0.137,43,1 +7,152,88,44,0,50.0,0.337,36,1 +2,99,52,15,94,24.6,0.637,21,0 +1,109,56,21,135,25.2,0.833,23,0 +2,88,74,19,53,29.0,0.229,22,0 +17,163,72,41,114,40.9,0.817,47,1 +4,151,90,38,0,29.7,0.294,36,0 +7,102,74,40,105,37.2,0.204,45,0 +0,114,80,34,285,44.2,0.167,27,0 +2,100,64,23,0,29.7,0.368,21,0 +0,131,88,0,0,31.6,0.743,32,1 +6,104,74,18,156,29.9,0.722,41,1 +3,148,66,25,0,32.5,0.256,22,0 +4,120,68,0,0,29.6,0.709,34,0 +4,110,66,0,0,31.9,0.471,29,0 +3,111,90,12,78,28.4,0.495,29,0 +6,102,82,0,0,30.8,0.180,36,1 +6,134,70,23,130,35.4,0.542,29,1 +2,87,0,23,0,28.9,0.773,25,0 +1,79,60,42,48,43.5,0.678,23,0 +2,75,64,24,55,29.7,0.370,33,0 +8,179,72,42,130,32.7,0.719,36,1 +6,85,78,0,0,31.2,0.382,42,0 +0,129,110,46,130,67.1,0.319,26,1 +5,143,78,0,0,45.0,0.190,47,0 +5,130,82,0,0,39.1,0.956,37,1 +6,87,80,0,0,23.2,0.084,32,0 +0,119,64,18,92,34.9,0.725,23,0 +1,0,74,20,23,27.7,0.299,21,0 +5,73,60,0,0,26.8,0.268,27,0 +4,141,74,0,0,27.6,0.244,40,0 +7,194,68,28,0,35.9,0.745,41,1 +8,181,68,36,495,30.1,0.615,60,1 +1,128,98,41,58,32.0,1.321,33,1 +8,109,76,39,114,27.9,0.640,31,1 +5,139,80,35,160,31.6,0.361,25,1 +3,111,62,0,0,22.6,0.142,21,0 +9,123,70,44,94,33.1,0.374,40,0 +7,159,66,0,0,30.4,0.383,36,1 +11,135,0,0,0,52.3,0.578,40,1 +8,85,55,20,0,24.4,0.136,42,0 +5,158,84,41,210,39.4,0.395,29,1 +1,105,58,0,0,24.3,0.187,21,0 +3,107,62,13,48,22.9,0.678,23,1 +4,109,64,44,99,34.8,0.905,26,1 +4,148,60,27,318,30.9,0.150,29,1 +0,113,80,16,0,31.0,0.874,21,0 +1,138,82,0,0,40.1,0.236,28,0 +0,108,68,20,0,27.3,0.787,32,0 +2,99,70,16,44,20.4,0.235,27,0 +6,103,72,32,190,37.7,0.324,55,0 +5,111,72,28,0,23.9,0.407,27,0 +8,196,76,29,280,37.5,0.605,57,1 +5,162,104,0,0,37.7,0.151,52,1 +1,96,64,27,87,33.2,0.289,21,0 +7,184,84,33,0,35.5,0.355,41,1 +2,81,60,22,0,27.7,0.290,25,0 +0,147,85,54,0,42.8,0.375,24,0 +7,179,95,31,0,34.2,0.164,60,0 +0,140,65,26,130,42.6,0.431,24,1 +9,112,82,32,175,34.2,0.260,36,1 +12,151,70,40,271,41.8,0.742,38,1 +5,109,62,41,129,35.8,0.514,25,1 +6,125,68,30,120,30.0,0.464,32,0 +5,85,74,22,0,29.0,1.224,32,1 +5,112,66,0,0,37.8,0.261,41,1 +0,177,60,29,478,34.6,1.072,21,1 +2,158,90,0,0,31.6,0.805,66,1 +7,119,0,0,0,25.2,0.209,37,0 +7,142,60,33,190,28.8,0.687,61,0 +1,100,66,15,56,23.6,0.666,26,0 +1,87,78,27,32,34.6,0.101,22,0 +0,101,76,0,0,35.7,0.198,26,0 +3,162,52,38,0,37.2,0.652,24,1 +4,197,70,39,744,36.7,2.329,31,0 +0,117,80,31,53,45.2,0.089,24,0 +4,142,86,0,0,44.0,0.645,22,1 +6,134,80,37,370,46.2,0.238,46,1 +1,79,80,25,37,25.4,0.583,22,0 +4,122,68,0,0,35.0,0.394,29,0 +3,74,68,28,45,29.7,0.293,23,0 +4,171,72,0,0,43.6,0.479,26,1 +7,181,84,21,192,35.9,0.586,51,1 +0,179,90,27,0,44.1,0.686,23,1 +9,164,84,21,0,30.8,0.831,32,1 +0,104,76,0,0,18.4,0.582,27,0 +1,91,64,24,0,29.2,0.192,21,0 +4,91,70,32,88,33.1,0.446,22,0 +3,139,54,0,0,25.6,0.402,22,1 +6,119,50,22,176,27.1,1.318,33,1 +2,146,76,35,194,38.2,0.329,29,0 +9,184,85,15,0,30.0,1.213,49,1 +10,122,68,0,0,31.2,0.258,41,0 +0,165,90,33,680,52.3,0.427,23,0 +9,124,70,33,402,35.4,0.282,34,0 +1,111,86,19,0,30.1,0.143,23,0 +9,106,52,0,0,31.2,0.380,42,0 +2,129,84,0,0,28.0,0.284,27,0 +2,90,80,14,55,24.4,0.249,24,0 +0,86,68,32,0,35.8,0.238,25,0 +12,92,62,7,258,27.6,0.926,44,1 +1,113,64,35,0,33.6,0.543,21,1 +3,111,56,39,0,30.1,0.557,30,0 +2,114,68,22,0,28.7,0.092,25,0 +1,193,50,16,375,25.9,0.655,24,0 +11,155,76,28,150,33.3,1.353,51,1 +3,191,68,15,130,30.9,0.299,34,0 +3,141,0,0,0,30.0,0.761,27,1 +4,95,70,32,0,32.1,0.612,24,0 +3,142,80,15,0,32.4,0.200,63,0 +4,123,62,0,0,32.0,0.226,35,1 +5,96,74,18,67,33.6,0.997,43,0 +0,138,0,0,0,36.3,0.933,25,1 +2,128,64,42,0,40.0,1.101,24,0 +0,102,52,0,0,25.1,0.078,21,0 +2,146,0,0,0,27.5,0.240,28,1 +10,101,86,37,0,45.6,1.136,38,1 +2,108,62,32,56,25.2,0.128,21,0 +3,122,78,0,0,23.0,0.254,40,0 +1,71,78,50,45,33.2,0.422,21,0 +13,106,70,0,0,34.2,0.251,52,0 +2,100,70,52,57,40.5,0.677,25,0 +7,106,60,24,0,26.5,0.296,29,1 +0,104,64,23,116,27.8,0.454,23,0 +5,114,74,0,0,24.9,0.744,57,0 +2,108,62,10,278,25.3,0.881,22,0 +0,146,70,0,0,37.9,0.334,28,1 +10,129,76,28,122,35.9,0.280,39,0 +7,133,88,15,155,32.4,0.262,37,0 +7,161,86,0,0,30.4,0.165,47,1 +2,108,80,0,0,27.0,0.259,52,1 +7,136,74,26,135,26.0,0.647,51,0 +5,155,84,44,545,38.7,0.619,34,0 +1,119,86,39,220,45.6,0.808,29,1 +4,96,56,17,49,20.8,0.340,26,0 +5,108,72,43,75,36.1,0.263,33,0 +0,78,88,29,40,36.9,0.434,21,0 +0,107,62,30,74,36.6,0.757,25,1 +2,128,78,37,182,43.3,1.224,31,1 +1,128,48,45,194,40.5,0.613,24,1 +0,161,50,0,0,21.9,0.254,65,0 +6,151,62,31,120,35.5,0.692,28,0 +2,146,70,38,360,28.0,0.337,29,1 +0,126,84,29,215,30.7,0.520,24,0 +14,100,78,25,184,36.6,0.412,46,1 +8,112,72,0,0,23.6,0.840,58,0 +0,167,0,0,0,32.3,0.839,30,1 +2,144,58,33,135,31.6,0.422,25,1 +5,77,82,41,42,35.8,0.156,35,0 +5,115,98,0,0,52.9,0.209,28,1 +3,150,76,0,0,21.0,0.207,37,0 +2,120,76,37,105,39.7,0.215,29,0 +10,161,68,23,132,25.5,0.326,47,1 +0,137,68,14,148,24.8,0.143,21,0 +0,128,68,19,180,30.5,1.391,25,1 +2,124,68,28,205,32.9,0.875,30,1 +6,80,66,30,0,26.2,0.313,41,0 +0,106,70,37,148,39.4,0.605,22,0 +2,155,74,17,96,26.6,0.433,27,1 +3,113,50,10,85,29.5,0.626,25,0 +7,109,80,31,0,35.9,1.127,43,1 +2,112,68,22,94,34.1,0.315,26,0 +3,99,80,11,64,19.3,0.284,30,0 +3,182,74,0,0,30.5,0.345,29,1 +3,115,66,39,140,38.1,0.150,28,0 +6,194,78,0,0,23.5,0.129,59,1 +4,129,60,12,231,27.5,0.527,31,0 +3,112,74,30,0,31.6,0.197,25,1 +0,124,70,20,0,27.4,0.254,36,1 +13,152,90,33,29,26.8,0.731,43,1 +2,112,75,32,0,35.7,0.148,21,0 +1,157,72,21,168,25.6,0.123,24,0 +1,122,64,32,156,35.1,0.692,30,1 +10,179,70,0,0,35.1,0.200,37,0 +2,102,86,36,120,45.5,0.127,23,1 +6,105,70,32,68,30.8,0.122,37,0 +8,118,72,19,0,23.1,1.476,46,0 +2,87,58,16,52,32.7,0.166,25,0 +1,180,0,0,0,43.3,0.282,41,1 +12,106,80,0,0,23.6,0.137,44,0 +1,95,60,18,58,23.9,0.260,22,0 +0,165,76,43,255,47.9,0.259,26,0 +0,117,0,0,0,33.8,0.932,44,0 +5,115,76,0,0,31.2,0.343,44,1 +9,152,78,34,171,34.2,0.893,33,1 +7,178,84,0,0,39.9,0.331,41,1 +1,130,70,13,105,25.9,0.472,22,0 +1,95,74,21,73,25.9,0.673,36,0 +1,0,68,35,0,32.0,0.389,22,0 +5,122,86,0,0,34.7,0.290,33,0 +8,95,72,0,0,36.8,0.485,57,0 +8,126,88,36,108,38.5,0.349,49,0 +1,139,46,19,83,28.7,0.654,22,0 +3,116,0,0,0,23.5,0.187,23,0 +3,99,62,19,74,21.8,0.279,26,0 +5,0,80,32,0,41.0,0.346,37,1 +4,92,80,0,0,42.2,0.237,29,0 +4,137,84,0,0,31.2,0.252,30,0 +3,61,82,28,0,34.4,0.243,46,0 +1,90,62,12,43,27.2,0.580,24,0 +3,90,78,0,0,42.7,0.559,21,0 +9,165,88,0,0,30.4,0.302,49,1 +1,125,50,40,167,33.3,0.962,28,1 +13,129,0,30,0,39.9,0.569,44,1 +12,88,74,40,54,35.3,0.378,48,0 +1,196,76,36,249,36.5,0.875,29,1 +5,189,64,33,325,31.2,0.583,29,1 +5,158,70,0,0,29.8,0.207,63,0 +5,103,108,37,0,39.2,0.305,65,0 +4,146,78,0,0,38.5,0.520,67,1 +4,147,74,25,293,34.9,0.385,30,0 +5,99,54,28,83,34.0,0.499,30,0 +6,124,72,0,0,27.6,0.368,29,1 +0,101,64,17,0,21.0,0.252,21,0 +3,81,86,16,66,27.5,0.306,22,0 +1,133,102,28,140,32.8,0.234,45,1 +3,173,82,48,465,38.4,2.137,25,1 +0,118,64,23,89,0.0,1.731,21,0 +0,84,64,22,66,35.8,0.545,21,0 +2,105,58,40,94,34.9,0.225,25,0 +2,122,52,43,158,36.2,0.816,28,0 +12,140,82,43,325,39.2,0.528,58,1 +0,98,82,15,84,25.2,0.299,22,0 +1,87,60,37,75,37.2,0.509,22,0 +4,156,75,0,0,48.3,0.238,32,1 +0,93,100,39,72,43.4,1.021,35,0 +1,107,72,30,82,30.8,0.821,24,0 +0,105,68,22,0,20.0,0.236,22,0 +1,109,60,8,182,25.4,0.947,21,0 +1,90,62,18,59,25.1,1.268,25,0 +1,125,70,24,110,24.3,0.221,25,0 +1,119,54,13,50,22.3,0.205,24,0 +5,116,74,29,0,32.3,0.660,35,1 +8,105,100,36,0,43.3,0.239,45,1 +5,144,82,26,285,32.0,0.452,58,1 +3,100,68,23,81,31.6,0.949,28,0 +1,100,66,29,196,32.0,0.444,42,0 +5,166,76,0,0,45.7,0.340,27,1 +1,131,64,14,415,23.7,0.389,21,0 +4,116,72,12,87,22.1,0.463,37,0 +4,158,78,0,0,32.9,0.803,31,1 +2,127,58,24,275,27.7,1.600,25,0 +3,96,56,34,115,24.7,0.944,39,0 +0,131,66,40,0,34.3,0.196,22,1 +3,82,70,0,0,21.1,0.389,25,0 +3,193,70,31,0,34.9,0.241,25,1 +4,95,64,0,0,32.0,0.161,31,1 +6,137,61,0,0,24.2,0.151,55,0 +5,136,84,41,88,35.0,0.286,35,1 +9,72,78,25,0,31.6,0.280,38,0 +5,168,64,0,0,32.9,0.135,41,1 +2,123,48,32,165,42.1,0.520,26,0 +4,115,72,0,0,28.9,0.376,46,1 +0,101,62,0,0,21.9,0.336,25,0 +8,197,74,0,0,25.9,1.191,39,1 +1,172,68,49,579,42.4,0.702,28,1 +6,102,90,39,0,35.7,0.674,28,0 +1,112,72,30,176,34.4,0.528,25,0 +1,143,84,23,310,42.4,1.076,22,0 +1,143,74,22,61,26.2,0.256,21,0 +0,138,60,35,167,34.6,0.534,21,1 +3,173,84,33,474,35.7,0.258,22,1 +1,97,68,21,0,27.2,1.095,22,0 +4,144,82,32,0,38.5,0.554,37,1 +1,83,68,0,0,18.2,0.624,27,0 +3,129,64,29,115,26.4,0.219,28,1 +1,119,88,41,170,45.3,0.507,26,0 +2,94,68,18,76,26.0,0.561,21,0 +0,102,64,46,78,40.6,0.496,21,0 +2,115,64,22,0,30.8,0.421,21,0 +8,151,78,32,210,42.9,0.516,36,1 +4,184,78,39,277,37.0,0.264,31,1 +0,94,0,0,0,0.0,0.256,25,0 +1,181,64,30,180,34.1,0.328,38,1 +0,135,94,46,145,40.6,0.284,26,0 +1,95,82,25,180,35.0,0.233,43,1 +2,99,0,0,0,22.2,0.108,23,0 +3,89,74,16,85,30.4,0.551,38,0 +1,80,74,11,60,30.0,0.527,22,0 +2,139,75,0,0,25.6,0.167,29,0 +1,90,68,8,0,24.5,1.138,36,0 +0,141,0,0,0,42.4,0.205,29,1 +12,140,85,33,0,37.4,0.244,41,0 +5,147,75,0,0,29.9,0.434,28,0 +1,97,70,15,0,18.2,0.147,21,0 +6,107,88,0,0,36.8,0.727,31,0 +0,189,104,25,0,34.3,0.435,41,1 +2,83,66,23,50,32.2,0.497,22,0 +4,117,64,27,120,33.2,0.230,24,0 +8,108,70,0,0,30.5,0.955,33,1 +4,117,62,12,0,29.7,0.380,30,1 +0,180,78,63,14,59.4,2.420,25,1 +1,100,72,12,70,25.3,0.658,28,0 +0,95,80,45,92,36.5,0.330,26,0 +0,104,64,37,64,33.6,0.510,22,1 +0,120,74,18,63,30.5,0.285,26,0 +1,82,64,13,95,21.2,0.415,23,0 +2,134,70,0,0,28.9,0.542,23,1 +0,91,68,32,210,39.9,0.381,25,0 +2,119,0,0,0,19.6,0.832,72,0 +2,100,54,28,105,37.8,0.498,24,0 +14,175,62,30,0,33.6,0.212,38,1 +1,135,54,0,0,26.7,0.687,62,0 +5,86,68,28,71,30.2,0.364,24,0 +10,148,84,48,237,37.6,1.001,51,1 +9,134,74,33,60,25.9,0.460,81,0 +9,120,72,22,56,20.8,0.733,48,0 +1,71,62,0,0,21.8,0.416,26,0 +8,74,70,40,49,35.3,0.705,39,0 +5,88,78,30,0,27.6,0.258,37,0 +10,115,98,0,0,24.0,1.022,34,0 +0,124,56,13,105,21.8,0.452,21,0 +0,74,52,10,36,27.8,0.269,22,0 +0,97,64,36,100,36.8,0.600,25,0 +8,120,0,0,0,30.0,0.183,38,1 +6,154,78,41,140,46.1,0.571,27,0 +1,144,82,40,0,41.3,0.607,28,0 +0,137,70,38,0,33.2,0.170,22,0 +0,119,66,27,0,38.8,0.259,22,0 +7,136,90,0,0,29.9,0.210,50,0 +4,114,64,0,0,28.9,0.126,24,0 +0,137,84,27,0,27.3,0.231,59,0 +2,105,80,45,191,33.7,0.711,29,1 +7,114,76,17,110,23.8,0.466,31,0 +8,126,74,38,75,25.9,0.162,39,0 +4,132,86,31,0,28.0,0.419,63,0 +3,158,70,30,328,35.5,0.344,35,1 +0,123,88,37,0,35.2,0.197,29,0 +4,85,58,22,49,27.8,0.306,28,0 +0,84,82,31,125,38.2,0.233,23,0 +0,145,0,0,0,44.2,0.630,31,1 +0,135,68,42,250,42.3,0.365,24,1 +1,139,62,41,480,40.7,0.536,21,0 +0,173,78,32,265,46.5,1.159,58,0 +4,99,72,17,0,25.6,0.294,28,0 +8,194,80,0,0,26.1,0.551,67,0 +2,83,65,28,66,36.8,0.629,24,0 +2,89,90,30,0,33.5,0.292,42,0 +4,99,68,38,0,32.8,0.145,33,0 +4,125,70,18,122,28.9,1.144,45,1 +3,80,0,0,0,0.0,0.174,22,0 +6,166,74,0,0,26.6,0.304,66,0 +5,110,68,0,0,26.0,0.292,30,0 +2,81,72,15,76,30.1,0.547,25,0 +7,195,70,33,145,25.1,0.163,55,1 +6,154,74,32,193,29.3,0.839,39,0 +2,117,90,19,71,25.2,0.313,21,0 +3,84,72,32,0,37.2,0.267,28,0 +6,0,68,41,0,39.0,0.727,41,1 +7,94,64,25,79,33.3,0.738,41,0 +3,96,78,39,0,37.3,0.238,40,0 +10,75,82,0,0,33.3,0.263,38,0 +0,180,90,26,90,36.5,0.314,35,1 +1,130,60,23,170,28.6,0.692,21,0 +2,84,50,23,76,30.4,0.968,21,0 +8,120,78,0,0,25.0,0.409,64,0 +12,84,72,31,0,29.7,0.297,46,1 +0,139,62,17,210,22.1,0.207,21,0 +9,91,68,0,0,24.2,0.200,58,0 +2,91,62,0,0,27.3,0.525,22,0 +3,99,54,19,86,25.6,0.154,24,0 +3,163,70,18,105,31.6,0.268,28,1 +9,145,88,34,165,30.3,0.771,53,1 +7,125,86,0,0,37.6,0.304,51,0 +13,76,60,0,0,32.8,0.180,41,0 +6,129,90,7,326,19.6,0.582,60,0 +2,68,70,32,66,25.0,0.187,25,0 +3,124,80,33,130,33.2,0.305,26,0 +6,114,0,0,0,0.0,0.189,26,0 +9,130,70,0,0,34.2,0.652,45,1 +3,125,58,0,0,31.6,0.151,24,0 +3,87,60,18,0,21.8,0.444,21,0 +1,97,64,19,82,18.2,0.299,21,0 +3,116,74,15,105,26.3,0.107,24,0 +0,117,66,31,188,30.8,0.493,22,0 +0,111,65,0,0,24.6,0.660,31,0 +2,122,60,18,106,29.8,0.717,22,0 +0,107,76,0,0,45.3,0.686,24,0 +1,86,66,52,65,41.3,0.917,29,0 +6,91,0,0,0,29.8,0.501,31,0 +1,77,56,30,56,33.3,1.251,24,0 +4,132,0,0,0,32.9,0.302,23,1 +0,105,90,0,0,29.6,0.197,46,0 +0,57,60,0,0,21.7,0.735,67,0 +0,127,80,37,210,36.3,0.804,23,0 +3,129,92,49,155,36.4,0.968,32,1 +8,100,74,40,215,39.4,0.661,43,1 +3,128,72,25,190,32.4,0.549,27,1 +10,90,85,32,0,34.9,0.825,56,1 +4,84,90,23,56,39.5,0.159,25,0 +1,88,78,29,76,32.0,0.365,29,0 +8,186,90,35,225,34.5,0.423,37,1 +5,187,76,27,207,43.6,1.034,53,1 +4,131,68,21,166,33.1,0.160,28,0 +1,164,82,43,67,32.8,0.341,50,0 +4,189,110,31,0,28.5,0.680,37,0 +1,116,70,28,0,27.4,0.204,21,0 +3,84,68,30,106,31.9,0.591,25,0 +6,114,88,0,0,27.8,0.247,66,0 +1,88,62,24,44,29.9,0.422,23,0 +1,84,64,23,115,36.9,0.471,28,0 +7,124,70,33,215,25.5,0.161,37,0 +1,97,70,40,0,38.1,0.218,30,0 +8,110,76,0,0,27.8,0.237,58,0 +11,103,68,40,0,46.2,0.126,42,0 +11,85,74,0,0,30.1,0.300,35,0 +6,125,76,0,0,33.8,0.121,54,1 +0,198,66,32,274,41.3,0.502,28,1 +1,87,68,34,77,37.6,0.401,24,0 +6,99,60,19,54,26.9,0.497,32,0 +0,91,80,0,0,32.4,0.601,27,0 +2,95,54,14,88,26.1,0.748,22,0 +1,99,72,30,18,38.6,0.412,21,0 +6,92,62,32,126,32.0,0.085,46,0 +4,154,72,29,126,31.3,0.338,37,0 +0,121,66,30,165,34.3,0.203,33,1 +3,78,70,0,0,32.5,0.270,39,0 +2,130,96,0,0,22.6,0.268,21,0 +3,111,58,31,44,29.5,0.430,22,0 +2,98,60,17,120,34.7,0.198,22,0 +1,143,86,30,330,30.1,0.892,23,0 +1,119,44,47,63,35.5,0.280,25,0 +6,108,44,20,130,24.0,0.813,35,0 +2,118,80,0,0,42.9,0.693,21,1 +10,133,68,0,0,27.0,0.245,36,0 +2,197,70,99,0,34.7,0.575,62,1 +0,151,90,46,0,42.1,0.371,21,1 +6,109,60,27,0,25.0,0.206,27,0 +12,121,78,17,0,26.5,0.259,62,0 +8,100,76,0,0,38.7,0.190,42,0 +8,124,76,24,600,28.7,0.687,52,1 +1,93,56,11,0,22.5,0.417,22,0 +8,143,66,0,0,34.9,0.129,41,1 +6,103,66,0,0,24.3,0.249,29,0 +3,176,86,27,156,33.3,1.154,52,1 +0,73,0,0,0,21.1,0.342,25,0 +11,111,84,40,0,46.8,0.925,45,1 +2,112,78,50,140,39.4,0.175,24,0 +3,132,80,0,0,34.4,0.402,44,1 +2,82,52,22,115,28.5,1.699,25,0 +6,123,72,45,230,33.6,0.733,34,0 +0,188,82,14,185,32.0,0.682,22,1 +0,67,76,0,0,45.3,0.194,46,0 +1,89,24,19,25,27.8,0.559,21,0 +1,173,74,0,0,36.8,0.088,38,1 +1,109,38,18,120,23.1,0.407,26,0 +1,108,88,19,0,27.1,0.400,24,0 +6,96,0,0,0,23.7,0.190,28,0 +1,124,74,36,0,27.8,0.100,30,0 +7,150,78,29,126,35.2,0.692,54,1 +4,183,0,0,0,28.4,0.212,36,1 +1,124,60,32,0,35.8,0.514,21,0 +1,181,78,42,293,40.0,1.258,22,1 +1,92,62,25,41,19.5,0.482,25,0 +0,152,82,39,272,41.5,0.270,27,0 +1,111,62,13,182,24.0,0.138,23,0 +3,106,54,21,158,30.9,0.292,24,0 +3,174,58,22,194,32.9,0.593,36,1 +7,168,88,42,321,38.2,0.787,40,1 +6,105,80,28,0,32.5,0.878,26,0 +11,138,74,26,144,36.1,0.557,50,1 +3,106,72,0,0,25.8,0.207,27,0 +6,117,96,0,0,28.7,0.157,30,0 +2,68,62,13,15,20.1,0.257,23,0 +9,112,82,24,0,28.2,1.282,50,1 +0,119,0,0,0,32.4,0.141,24,1 +2,112,86,42,160,38.4,0.246,28,0 +2,92,76,20,0,24.2,1.698,28,0 +6,183,94,0,0,40.8,1.461,45,0 +0,94,70,27,115,43.5,0.347,21,0 +2,108,64,0,0,30.8,0.158,21,0 +4,90,88,47,54,37.7,0.362,29,0 +0,125,68,0,0,24.7,0.206,21,0 +0,132,78,0,0,32.4,0.393,21,0 +5,128,80,0,0,34.6,0.144,45,0 +4,94,65,22,0,24.7,0.148,21,0 +7,114,64,0,0,27.4,0.732,34,1 +0,102,78,40,90,34.5,0.238,24,0 +2,111,60,0,0,26.2,0.343,23,0 +1,128,82,17,183,27.5,0.115,22,0 +10,92,62,0,0,25.9,0.167,31,0 +13,104,72,0,0,31.2,0.465,38,1 +5,104,74,0,0,28.8,0.153,48,0 +2,94,76,18,66,31.6,0.649,23,0 +7,97,76,32,91,40.9,0.871,32,1 +1,100,74,12,46,19.5,0.149,28,0 +0,102,86,17,105,29.3,0.695,27,0 +4,128,70,0,0,34.3,0.303,24,0 +6,147,80,0,0,29.5,0.178,50,1 +4,90,0,0,0,28.0,0.610,31,0 +3,103,72,30,152,27.6,0.730,27,0 +2,157,74,35,440,39.4,0.134,30,0 +1,167,74,17,144,23.4,0.447,33,1 +0,179,50,36,159,37.8,0.455,22,1 +11,136,84,35,130,28.3,0.260,42,1 +0,107,60,25,0,26.4,0.133,23,0 +1,91,54,25,100,25.2,0.234,23,0 +1,117,60,23,106,33.8,0.466,27,0 +5,123,74,40,77,34.1,0.269,28,0 +2,120,54,0,0,26.8,0.455,27,0 +1,106,70,28,135,34.2,0.142,22,0 +2,155,52,27,540,38.7,0.240,25,1 +2,101,58,35,90,21.8,0.155,22,0 +1,120,80,48,200,38.9,1.162,41,0 +11,127,106,0,0,39.0,0.190,51,0 +3,80,82,31,70,34.2,1.292,27,1 +10,162,84,0,0,27.7,0.182,54,0 +1,199,76,43,0,42.9,1.394,22,1 +8,167,106,46,231,37.6,0.165,43,1 +9,145,80,46,130,37.9,0.637,40,1 +6,115,60,39,0,33.7,0.245,40,1 +1,112,80,45,132,34.8,0.217,24,0 +4,145,82,18,0,32.5,0.235,70,1 +10,111,70,27,0,27.5,0.141,40,1 +6,98,58,33,190,34.0,0.430,43,0 +9,154,78,30,100,30.9,0.164,45,0 +6,165,68,26,168,33.6,0.631,49,0 +1,99,58,10,0,25.4,0.551,21,0 +10,68,106,23,49,35.5,0.285,47,0 +3,123,100,35,240,57.3,0.880,22,0 +8,91,82,0,0,35.6,0.587,68,0 +6,195,70,0,0,30.9,0.328,31,1 +9,156,86,0,0,24.8,0.230,53,1 +0,93,60,0,0,35.3,0.263,25,0 +3,121,52,0,0,36.0,0.127,25,1 +2,101,58,17,265,24.2,0.614,23,0 +2,56,56,28,45,24.2,0.332,22,0 +0,162,76,36,0,49.6,0.364,26,1 +0,95,64,39,105,44.6,0.366,22,0 +4,125,80,0,0,32.3,0.536,27,1 +5,136,82,0,0,0.0,0.640,69,0 +2,129,74,26,205,33.2,0.591,25,0 +3,130,64,0,0,23.1,0.314,22,0 +1,107,50,19,0,28.3,0.181,29,0 +1,140,74,26,180,24.1,0.828,23,0 +1,144,82,46,180,46.1,0.335,46,1 +8,107,80,0,0,24.6,0.856,34,0 +13,158,114,0,0,42.3,0.257,44,1 +2,121,70,32,95,39.1,0.886,23,0 +7,129,68,49,125,38.5,0.439,43,1 +2,90,60,0,0,23.5,0.191,25,0 +7,142,90,24,480,30.4,0.128,43,1 +3,169,74,19,125,29.9,0.268,31,1 +0,99,0,0,0,25.0,0.253,22,0 +4,127,88,11,155,34.5,0.598,28,0 +4,118,70,0,0,44.5,0.904,26,0 +2,122,76,27,200,35.9,0.483,26,0 +6,125,78,31,0,27.6,0.565,49,1 +1,168,88,29,0,35.0,0.905,52,1 +2,129,0,0,0,38.5,0.304,41,0 +4,110,76,20,100,28.4,0.118,27,0 +6,80,80,36,0,39.8,0.177,28,0 +10,115,0,0,0,0.0,0.261,30,1 +2,127,46,21,335,34.4,0.176,22,0 +9,164,78,0,0,32.8,0.148,45,1 +2,93,64,32,160,38.0,0.674,23,1 +3,158,64,13,387,31.2,0.295,24,0 +5,126,78,27,22,29.6,0.439,40,0 +10,129,62,36,0,41.2,0.441,38,1 +0,134,58,20,291,26.4,0.352,21,0 +3,102,74,0,0,29.5,0.121,32,0 +7,187,50,33,392,33.9,0.826,34,1 +3,173,78,39,185,33.8,0.970,31,1 +10,94,72,18,0,23.1,0.595,56,0 +1,108,60,46,178,35.5,0.415,24,0 +5,97,76,27,0,35.6,0.378,52,1 +4,83,86,19,0,29.3,0.317,34,0 +1,114,66,36,200,38.1,0.289,21,0 +1,149,68,29,127,29.3,0.349,42,1 +5,117,86,30,105,39.1,0.251,42,0 +1,111,94,0,0,32.8,0.265,45,0 +4,112,78,40,0,39.4,0.236,38,0 +1,116,78,29,180,36.1,0.496,25,0 +0,141,84,26,0,32.4,0.433,22,0 +2,175,88,0,0,22.9,0.326,22,0 +2,92,52,0,0,30.1,0.141,22,0 +3,130,78,23,79,28.4,0.323,34,1 +8,120,86,0,0,28.4,0.259,22,1 +2,174,88,37,120,44.5,0.646,24,1 +2,106,56,27,165,29.0,0.426,22,0 +2,105,75,0,0,23.3,0.560,53,0 +4,95,60,32,0,35.4,0.284,28,0 +0,126,86,27,120,27.4,0.515,21,0 +8,65,72,23,0,32.0,0.600,42,0 +2,99,60,17,160,36.6,0.453,21,0 +1,102,74,0,0,39.5,0.293,42,1 +11,120,80,37,150,42.3,0.785,48,1 +3,102,44,20,94,30.8,0.400,26,0 +1,109,58,18,116,28.5,0.219,22,0 +9,140,94,0,0,32.7,0.734,45,1 +13,153,88,37,140,40.6,1.174,39,0 +12,100,84,33,105,30.0,0.488,46,0 +1,147,94,41,0,49.3,0.358,27,1 +1,81,74,41,57,46.3,1.096,32,0 +3,187,70,22,200,36.4,0.408,36,1 +6,162,62,0,0,24.3,0.178,50,1 +4,136,70,0,0,31.2,1.182,22,1 +1,121,78,39,74,39.0,0.261,28,0 +3,108,62,24,0,26.0,0.223,25,0 +0,181,88,44,510,43.3,0.222,26,1 +8,154,78,32,0,32.4,0.443,45,1 +1,128,88,39,110,36.5,1.057,37,1 +7,137,90,41,0,32.0,0.391,39,0 +0,123,72,0,0,36.3,0.258,52,1 +1,106,76,0,0,37.5,0.197,26,0 +6,190,92,0,0,35.5,0.278,66,1 +2,88,58,26,16,28.4,0.766,22,0 +9,170,74,31,0,44.0,0.403,43,1 +9,89,62,0,0,22.5,0.142,33,0 +10,101,76,48,180,32.9,0.171,63,0 +2,122,70,27,0,36.8,0.340,27,0 +5,121,72,23,112,26.2,0.245,30,0 +1,126,60,0,0,30.1,0.349,47,1 +1,93,70,31,0,30.4,0.315,23,0