chapter_4.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "knob_weight = 0.5\n",
    "inputs = 0.5\n",
    "goal_pred = 0.8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred = inputs * knob_weight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "error = (pred - goal_pred) ** pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0.6089416428154534+0.6089416428154533j)\n"
     ]
    }
   ],
   "source": [
    "print(error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hot and cold learning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### An empty network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "weight = 0.1\n",
    "lr = 0.01\n",
    "\n",
    "def neural_network(inputs, weight):\n",
    "    return inputs * weight"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### PREDICT: making a prediction and evaluating error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.022499999999999975\n"
     ]
    }
   ],
   "source": [
    "number_of_toes = [8.5]\n",
    "win_or_lose_binary = [1] # WON!!!\n",
    "\n",
    "inputs = number_of_toes[0]\n",
    "true = win_or_lose_binary[0]\n",
    "\n",
    "pred = neural_network(inputs, weight)\n",
    "\n",
    "error = (pred - true) ** 2 # Forces the raw error to be posibive by multiplying it by itself. Negative error wouldn't make sense.\n",
    "print(error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### COMPARE: making a prediction with higher weight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.49000000000000027\n"
     ]
    }
   ],
   "source": [
    "lr = 0.1\n",
    "p_up = neural_network(inputs, weight+lr) # Higher\n",
    "e_up = (p_up - true) ** 2\n",
    "print(e_up)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### COMPARE: Making a prediction with a lower weight and evaluating error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.05522499999999994\n"
     ]
    }
   ],
   "source": [
    "lr = 0.01\n",
    "p_dn = neural_network(inputs, weight-lr)\n",
    "e_dn = (p_dn - true) ** 2\n",
    "print(e_dn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### COMPARE + LEARN: Comparing the errors and setting the new weight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "if(error > e_dn or error > e_up):\n",
    "    if(e_dn < e_up):\n",
    "        weight -= lr\n",
    "    \n",
    "    if(e_up < e_up):\n",
    "        weight += lr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### FULL NETWORK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "weight = 0.5\n",
    "inputs = 0.5\n",
    "goal_prediction = 0.8\n",
    "\n",
    "step_amount = 0.001 # How much to move the weights each iteration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error:0.30250000000000005 Prediction:0.25\n",
      "Error:0.3019502500000001 Prediction:0.2505\n",
      "Error:0.30140100000000003 Prediction:0.251\n",
      "Error:0.30085225 Prediction:0.2515\n",
      "Error:0.30030400000000007 Prediction:0.252\n",
      "Error:0.2997562500000001 Prediction:0.2525\n",
      "Error:0.29920900000000006 Prediction:0.253\n",
      "Error:0.29866224999999996 Prediction:0.2535\n",
      "Error:0.29811600000000005 Prediction:0.254\n",
      "Error:0.2975702500000001 Prediction:0.2545\n",
      "Error:0.29702500000000004 Prediction:0.255\n",
      "Error:0.29648025 Prediction:0.2555\n",
      "Error:0.29593600000000003 Prediction:0.256\n",
      "Error:0.2953922500000001 Prediction:0.2565\n",
      "Error:0.294849 Prediction:0.257\n",
      "Error:0.29430625 Prediction:0.2575\n",
      "Error:0.293764 Prediction:0.258\n",
      "Error:0.2932222500000001 Prediction:0.2585\n",
      "Error:0.292681 Prediction:0.259\n",
      "Error:0.29214025 Prediction:0.2595\n"
     ]
    }
   ],
   "source": [
    "#for iteration in range(1101):\n",
    "for iteration in range(20): # Repeat learning many times so the error can keep getting smaller\n",
    "    \n",
    "    prediction = inputs * weight\n",
    "    error = (prediction - goal_prediction) ** 2\n",
    "    \n",
    "    print(\"Error:\" + str(error) + \" Prediction:\" + str(prediction))\n",
    "    \n",
    "    # Try up\n",
    "    up_prediction = inputs * (weight + step_amount)\n",
    "    up_error = (goal_prediction - up_prediction) ** 2\n",
    "    \n",
    "    # Try down\n",
    "    down_prediction = inputs * (weight - step_amount)\n",
    "    down_error = (goal_prediction - down_prediction) ** 2\n",
    "    \n",
    "    if(down_error < up_error):\n",
    "        weight = weight - step_amount  # if down is better, go down!\n",
    "    \n",
    "    if(down_error > up_error):\n",
    "        weight = weight + step_amount  # if up is better, go up!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gradient descent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Calculating both direction and amount from error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: 0.30250000000000005 \t Prediction: 0.25\n",
      "Error: 0.17015625000000004 \t Prediction: 0.3875\n",
      "Error: 0.095712890625 \t Prediction: 0.49062500000000003\n",
      "Error: 0.05383850097656251 \t Prediction: 0.56796875\n",
      "Error: 0.03028415679931642 \t Prediction: 0.6259765625\n",
      "Error: 0.0170348381996155 \t Prediction: 0.669482421875\n",
      "Error: 0.00958209648728372 \t Prediction: 0.70211181640625\n",
      "Error: 0.005389929274097089 \t Prediction: 0.7265838623046875\n",
      "Error: 0.0030318352166796153 \t Prediction: 0.7449378967285156\n",
      "Error: 0.0017054073093822882 \t Prediction: 0.7587034225463867\n",
      "Error: 0.0009592916115275371 \t Prediction: 0.76902756690979\n",
      "Error: 0.0005396015314842384 \t Prediction: 0.7767706751823426\n",
      "Error: 0.000303525861459885 \t Prediction: 0.7825780063867569\n",
      "Error: 0.00017073329707118678 \t Prediction: 0.7869335047900676\n",
      "Error: 9.603747960254256e-05 \t Prediction: 0.7902001285925507\n",
      "Error: 5.402108227642978e-05 \t Prediction: 0.7926500964444131\n",
      "Error: 3.038685878049206e-05 \t Prediction: 0.7944875723333098\n",
      "Error: 1.7092608064027242e-05 \t Prediction: 0.7958656792499823\n",
      "Error: 9.614592036015323e-06 \t Prediction: 0.7968992594374867\n",
      "Error: 5.408208020258491e-06 \t Prediction: 0.7976744445781151\n"
     ]
    }
   ],
   "source": [
    "weight = 0.5\n",
    "goal_pred = 0.8\n",
    "inputs = 0.5\n",
    "\n",
    "for iteration in range(20):\n",
    "    pred = inputs * weight\n",
    "    error = (pred - goal_pred) ** 2\n",
    "    direction_and_amount = (pred - goal_pred) * inputs\n",
    "    weight = weight - direction_and_amount\n",
    "    \n",
    "    print(f'Error: {str(error)} \\t Prediction: {str(pred)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Empty network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "weight = 0.1\n",
    "alpha = 0.01\n",
    "\n",
    "def neural_network(inputs, weight):\n",
    "    prediction = inputs * weight\n",
    "    return prediction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### PREDICT: Making a prediction and evaluating error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_of_toes = [8.5]\n",
    "win_or_lose_binary = [1] # WON\n",
    "\n",
    "inputs = number_of_toes[0]\n",
    "goal_pred = win_or_lose_binary[0]\n",
    "\n",
    "pred = neural_network(inputs, weight)\n",
    "\n",
    "error = (pred - goal_pred) ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### COMPARE: calculating the node delta and putting it on the output node"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_of_toes = [8.5]\n",
    "win_or_lose_binary = [1] # WON\n",
    "\n",
    "inputs = number_of_toes[0]\n",
    "goal_pred = win_or_lose_binary[0]\n",
    "\n",
    "pred = neural_network(inputs, weight)\n",
    "\n",
    "error = (pred - goal_pred) ** 2\n",
    "\n",
    "delta = pred - goal_pred # Delta is a measurement of how much this node missed.\n",
    "                         # The true prediction is 1.0, and the network's prediction was 0.85\n",
    "                         # so the network was too low by 0.15. thus delta is NEGATIVE 0.15"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### LEARN: Calculating the weight delta and putting it on th weight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_of_toes = [8.5]\n",
    "win_or_lose_binary = [1] # WON\n",
    "\n",
    "inputs = number_of_toes[0]\n",
    "goal_pred = win_or_lose_binary[0]\n",
    "\n",
    "pred = neural_network(inputs, weight)\n",
    "\n",
    "error = (pred - goal_pred) ** 2\n",
    "\n",
    "delta = pred - goal_pred\n",
    "\n",
    "weight_delta = inputs * delta # weight_delta is a measure of how much a weight caused the network to miss. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "weight_delta is calculated by multiplying the weight's output node delta by the weight input.\n",
    "Thus, you create each weight_delta by SCALING its output node delta by weights input."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### LEARN: Updating the weight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_of_toes = [8.5]\n",
    "win_or_lose_binary = [1] # WON\n",
    "\n",
    "inputs = number_of_toes[0]\n",
    "goal_pred = win_or_lose_binary[0]\n",
    "\n",
    "pred = neural_network(inputs, weight)\n",
    "error = (pred - goal_pred) ** 2\n",
    "delta = pred - goal_pred\n",
    "weight_delta = inputs * delta\n",
    "\n",
    "alpha = 0.01 # Fixed before training\n",
    "\n",
    "weight -= weight_delta * alpha"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Single iteration (putting it all together)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: 0.6400000000000001; Prediction: 0.0\n",
      "Error: 0.3600000000000001; Prediction: 0.2\n",
      "Error: 0.2025; Prediction: 0.35000000000000003\n",
      "Error: 0.11390625000000001; Prediction: 0.4625\n"
     ]
    }
   ],
   "source": [
    "weight, goal_pred, inputs = (0.0, 0.8, 0.5)\n",
    "\n",
    "for iteration in range(4):\n",
    "    pred = inputs * weight\n",
    "    error = (pred - goal_pred) ** 2\n",
    "    delta = pred - goal_pred\n",
    "    weight_delta = inputs * delta\n",
    "    weight = weight - weight_delta\n",
    "    print(f'Error: {error}; Prediction: {pred}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Several learning steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-----\n",
      "Weight: 0.0\n",
      "Error: 0.6400000000000001; Prediction: 0.0\n",
      "Delta: -0.8; Weight Delta: -0.8800000000000001\n",
      "-----\n",
      "Weight: 0.8800000000000001\n",
      "Error: 0.02822400000000005; Prediction: 0.9680000000000002\n",
      "Delta: 0.16800000000000015; Weight Delta: 0.1848000000000002\n",
      "-----\n",
      "Weight: 0.6951999999999999\n",
      "Error: 0.0012446784000000064; Prediction: 0.76472\n",
      "Delta: -0.03528000000000009; Weight Delta: -0.0388080000000001\n",
      "-----\n",
      "Weight: 0.734008\n",
      "Error: 5.4890317439999896e-05; Prediction: 0.8074088\n",
      "Delta: 0.007408799999999993; Weight Delta: 0.008149679999999992\n",
      "-----\n",
      "Weight: 0.72585832\n",
      "Error: 2.4206629991042546e-06; Prediction: 0.798444152\n",
      "Delta: -0.0015558480000000818; Weight Delta: -0.0017114328000000902\n",
      "-----\n",
      "Weight: 0.7275697528\n",
      "Error: 1.0675123826048965e-07; Prediction: 0.80032672808\n",
      "Delta: 0.00032672808000000497; Weight Delta: 0.0003594008880000055\n",
      "-----\n",
      "Weight: 0.727210351912\n",
      "Error: 4.707729607278605e-09; Prediction: 0.7999313871032001\n",
      "Delta: -6.861289679993554e-05; Weight Delta: -7.54741864799291e-05\n",
      "-----\n",
      "Weight: 0.7272858260984799\n",
      "Error: 2.0761087567900285e-10; Prediction: 0.800014408708328\n",
      "Delta: 1.440870832791763e-05; Weight Delta: 1.5849579160709395e-05\n",
      "-----\n",
      "Weight: 0.7272699765193192\n",
      "Error: 9.155639616953562e-12; Prediction: 0.7999969741712513\n",
      "Delta: -3.025828748781656e-06; Weight Delta: -3.328411623659822e-06\n",
      "-----\n",
      "Weight: 0.7272733049309429\n",
      "Error: 4.037637070074764e-13; Prediction: 0.8000006354240372\n",
      "Delta: 6.354240371653219e-07; Weight Delta: 6.989664408818542e-07\n",
      "-----\n",
      "Weight: 0.727272605964502\n",
      "Error: 1.7805979451178055e-14; Prediction: 0.7999998665609523\n",
      "Delta: -1.3343904770035664e-07; Weight Delta: -1.4678295247039232e-07\n",
      "-----\n",
      "Weight: 0.7272727527474545\n",
      "Error: 7.852436931125126e-16; Prediction: 0.8000000280222\n",
      "Delta: 2.802220000486244e-08; Weight Delta: 3.082442000534869e-08\n",
      "-----\n",
      "Weight: 0.7272727219230345\n",
      "Error: 3.4629247924654347e-17; Prediction: 0.799999994115338\n",
      "Delta: -5.8846620909491776e-09; Weight Delta: -6.473128300044096e-09\n",
      "-----\n",
      "Weight: 0.7272727283961627\n",
      "Error: 1.527149822501334e-18; Prediction: 0.8000000012357791\n",
      "Delta: 1.2357790346584352e-09; Weight Delta: 1.3593569381242788e-09\n",
      "-----\n",
      "Weight: 0.7272727270368058\n",
      "Error: 6.734732561186023e-20; Prediction: 0.7999999997404864\n",
      "Delta: -2.595136328054082e-10; Weight Delta: -2.85464996085949e-10\n",
      "-----\n",
      "Weight: 0.7272727273222708\n",
      "Error: 2.9700157283779774e-21; Prediction: 0.8000000000544979\n",
      "Delta: 5.4497850676682447e-11; Weight Delta: 5.99476357443507e-11\n",
      "-----\n",
      "Weight: 0.7272727272623232\n",
      "Error: 1.3097685502671811e-22; Prediction: 0.7999999999885555\n",
      "Delta: -1.1444512004743501e-11; Weight Delta: -1.2588963205217852e-11\n",
      "-----\n",
      "Weight: 0.7272727272749121\n",
      "Error: 5.7758498393064944e-24; Prediction: 0.8000000000024033\n",
      "Delta: 2.4032997814060764e-12; Weight Delta: 2.643629759546684e-12\n",
      "-----\n",
      "Weight: 0.7272727272722684\n",
      "Error: 2.5472954648691306e-25; Prediction: 0.7999999999994953\n",
      "Delta: -5.047073869945962e-13; Weight Delta: -5.551781256940558e-13\n",
      "-----\n",
      "Weight: 0.7272727272728237\n",
      "Error: 1.124157604819052e-26; Prediction: 0.8000000000001061\n",
      "Delta: 1.0602629885170245e-13; Weight Delta: 1.166289287368727e-13\n",
      "-----\n",
      "Weight: 0.7272727272727071\n",
      "Error: 4.930380657631324e-28; Prediction: 0.7999999999999778\n",
      "Delta: -2.220446049250313e-14; Weight Delta: -2.4424906541753447e-14\n",
      "-----\n",
      "Weight: 0.7272727272727315\n",
      "Error: 2.1742978700154138e-29; Prediction: 0.8000000000000047\n",
      "Delta: 4.6629367034256575e-15; Weight Delta: 5.1292303737682235e-15\n",
      "-----\n",
      "Weight: 0.7272727272727264\n",
      "Error: 7.888609052210118e-31; Prediction: 0.7999999999999992\n",
      "Delta: -8.881784197001252e-16; Weight Delta: -9.769962616701378e-16\n",
      "-----\n",
      "Weight: 0.7272727272727274\n",
      "Error: 1.232595164407831e-32; Prediction: 0.8000000000000002\n",
      "Delta: 1.1102230246251565e-16; Weight Delta: 1.2212453270876723e-16\n",
      "-----\n",
      "Weight: 0.7272727272727273\n",
      "Error: 0.0; Prediction: 0.8\n",
      "Delta: 0.0; Weight Delta: 0.0\n"
     ]
    }
   ],
   "source": [
    "weight, goal_pred, inputs = (0.0, 0.8, 1.1)\n",
    "\n",
    "for iteration in range(25):\n",
    "    print(f'-----\\nWeight: {weight}')\n",
    "    pred = weight*inputs\n",
    "    error = (pred - goal_pred) ** 2\n",
    "    delta = pred - goal_pred\n",
    "    weight_delta = inputs * delta\n",
    "    weight = weight - weight_delta\n",
    "    print(f'Error: {error}; Prediction: {pred}')\n",
    "    print(f'Delta: {delta}; Weight Delta: {weight_delta}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# THE BIG RELATION BETWEEN ERROR AND WEIGHT: error = ((input * weight) - goal_pred) ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error:0.03999999999999998 Prediction:1.0\n",
      "Error:0.3599999999999998 Prediction:0.20000000000000018\n",
      "Error:3.2399999999999984 Prediction:2.5999999999999996\n",
      "Error:29.159999999999986 Prediction:-4.599999999999999\n",
      "Error:262.4399999999999 Prediction:16.999999999999996\n",
      "Error:2361.959999999998 Prediction:-47.79999999999998\n",
      "Error:21257.639999999978 Prediction:146.59999999999994\n",
      "Error:191318.75999999983 Prediction:-436.5999999999998\n",
      "Error:1721868.839999999 Prediction:1312.9999999999995\n",
      "Error:15496819.559999991 Prediction:-3935.799999999999\n",
      "Error:139471376.03999993 Prediction:11810.599999999997\n",
      "Error:1255242384.3599997 Prediction:-35428.59999999999\n",
      "Error:11297181459.239996 Prediction:106288.99999999999\n",
      "Error:101674633133.15994 Prediction:-318863.79999999993\n",
      "Error:915071698198.4395 Prediction:956594.5999999997\n",
      "Error:8235645283785.954 Prediction:-2869780.599999999\n",
      "Error:74120807554073.56 Prediction:8609344.999999996\n",
      "Error:667087267986662.1 Prediction:-25828031.799999986\n",
      "Error:6003785411879960.0 Prediction:77484098.59999996\n",
      "Error:5.403406870691965e+16 Prediction:-232452292.5999999\n",
      "Error:4.8630661836227686e+17 Prediction:697356880.9999998\n",
      "Error:4.376759565260492e+18 Prediction:-2092070639.7999995\n",
      "Error:3.939083608734443e+19 Prediction:6276211922.599998\n",
      "Error:3.545175247860998e+20 Prediction:-18828635764.599995\n",
      "Error:3.1906577230748986e+21 Prediction:56485907296.999985\n"
     ]
    }
   ],
   "source": [
    "weight = 0.5\n",
    "goal_pred = 0.8\n",
    "input = 2\n",
    "\n",
    "for iteration in range(25):\n",
    "    pred = input * weight\n",
    "    error = (pred - goal_pred)**2\n",
    "    delta = pred - goal_pred\n",
    "    weight_delta = input * delta\n",
    "    weight = weight - weight_delta\n",
    "    print(\"Error:\" + str(error) + \" Prediction:\" + str(pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introducing Alpha to eliminate overcorrection (divergence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error:0.03999999999999998 Prediction:1.0\n",
      "Error:0.0144 Prediction:0.92\n",
      "Error:0.005183999999999993 Prediction:0.872\n",
      "Error:0.0018662400000000014 Prediction:0.8432000000000001\n",
      "Error:0.0006718464000000028 Prediction:0.8259200000000001\n",
      "Error:0.00024186470400000033 Prediction:0.815552\n",
      "Error:8.70712934399997e-05 Prediction:0.8093312\n",
      "Error:3.134566563839939e-05 Prediction:0.80559872\n",
      "Error:1.1284439629823931e-05 Prediction:0.803359232\n",
      "Error:4.062398266736526e-06 Prediction:0.8020155392\n",
      "Error:1.4624633760252567e-06 Prediction:0.8012093235200001\n",
      "Error:5.264868153690924e-07 Prediction:0.8007255941120001\n",
      "Error:1.8953525353291194e-07 Prediction:0.8004353564672001\n",
      "Error:6.82326912718715e-08 Prediction:0.8002612138803201\n",
      "Error:2.456376885786678e-08 Prediction:0.8001567283281921\n",
      "Error:8.842956788836216e-09 Prediction:0.8000940369969153\n",
      "Error:3.1834644439835434e-09 Prediction:0.8000564221981492\n",
      "Error:1.1460471998340758e-09 Prediction:0.8000338533188895\n",
      "Error:4.125769919393652e-10 Prediction:0.8000203119913337\n",
      "Error:1.485277170987127e-10 Prediction:0.8000121871948003\n",
      "Error:5.346997815521184e-11 Prediction:0.8000073123168802\n",
      "Error:1.92491921360711e-11 Prediction:0.8000043873901281\n",
      "Error:6.929709168868693e-12 Prediction:0.8000026324340769\n",
      "Error:2.4946953007927294e-12 Prediction:0.8000015794604461\n",
      "Error:8.980903083274679e-13 Prediction:0.8000009476762677\n"
     ]
    }
   ],
   "source": [
    "weight = 0.5\n",
    "goal_pred = 0.8\n",
    "input = 2\n",
    "alpha = 0.1\n",
    "\n",
    "for iteration in range(25):\n",
    "    pred = input * weight\n",
    "    error = (pred - goal_pred)**2\n",
    "    delta = pred - goal_pred\n",
    "    weight_delta = input * delta\n",
    "    weight = weight - (alpha*weight_delta)\n",
    "    print(\"Error:\" + str(error) + \" Prediction:\" + str(pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}