Chapter3 - Forward Propagation - Intro to Neural Prediction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A Simple Neural Network Making a Prediction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What is a Neural Network?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8500000000000001"
     ]
    }
   ],
   "source": [
    "weight = 0.1 \n",
    "function neural_network(input, weight)\n",
    "    prediction = input .* weight\n",
    "    return prediction\n",
    "end\n",
    "# How we use the network to predict something:\n",
    "\n",
    "number_of_toes = [8.5, 9.5, 10, 9]\n",
    "input = number_of_toes[1]\n",
    "pred = neural_network(input,weight)\n",
    "print(pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Making a Prediction with Multiple Inputs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Complete Runnable Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9800000000000001"
     ]
    }
   ],
   "source": [
    "function w_sum(a,b)\n",
    "    @assert length(a) == length(b)\n",
    "    output = 0\n",
    "    \n",
    "    for i=1:length(a)\n",
    "        output += (a[i] * b[i])\n",
    "    end\n",
    "    return output\n",
    "end\n",
    "\n",
    "weights = [0.1, 0.2, 0] \n",
    "    \n",
    "function neural_network(input, weights)\n",
    "    pred = w_sum(input, weights)\n",
    "end\n",
    "\n",
    "\n",
    "# This dataset is the current\n",
    "# status at the beginning of\n",
    "# each game for the first 4 games\n",
    "# in a season.\n",
    "\n",
    "# toes = current number of toes\n",
    "# wlrec = current games won (percent)\n",
    "# nfans = fan count (in millions)\n",
    "\n",
    "toes =  [8.5, 9.5, 9.9, 9.0]\n",
    "wlrec = [0.65, 0.8, 0.8, 0.9]\n",
    "nfans = [1.2, 1.3, 0.5, 1.0]\n",
    "\n",
    "# Input corresponds to every entry\n",
    "# for the first game of the season.\n",
    "\n",
    "input = [toes[1],wlrec[1],nfans[1]]\n",
    "pred = neural_network(input,weights)\n",
    "\n",
    "print(pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9800000000000001"
     ]
    }
   ],
   "source": [
    "weights = [0.1, 0.2, 0]\n",
    "\n",
    "function neural_network(input, weights)\n",
    "    sum(input .* weights)\n",
    "end\n",
    "\n",
    "    \n",
    "toes =  [8.5, 9.5, 9.9, 9.0]\n",
    "wlrec = [0.65, 0.8, 0.8, 0.9]\n",
    "nfans = [1.2, 1.3, 0.5, 1.0]\n",
    "\n",
    "# Input corresponds to every entry\n",
    "# for the first game of the season.\n",
    "\n",
    "input = [toes[1],wlrec[1],nfans[1]]\n",
    "pred = neural_network(input,weights)\n",
    "\n",
    "print(pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Making a Prediction with Multiple Outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.195, 0.13, 0.5850000000000001]"
     ]
    }
   ],
   "source": [
    "# Instead of predicting just \n",
    "# whether the team won or lost, \n",
    "# now we're also predicting whether\n",
    "# they are happy/sad AND the percentage\n",
    "# of the team that is hurt. We are\n",
    "# making this prediction using only\n",
    "# the current win/loss record.\n",
    "\n",
    "function ele_mul(number, vector)\n",
    "    output = [0.0,0.0,0.0]\n",
    "    @assert length(output) == length(vector)\n",
    "    for i=1:length(vector)\n",
    "        output[i] = number * vector[i]\n",
    "    end\n",
    "    return output\n",
    "end\n",
    "\n",
    "\n",
    "weights = [0.3, 0.2, 0.9] \n",
    "\n",
    "function neural_network(input, weights)\n",
    "    pred = ele_mul(input,weights)\n",
    "    return pred\n",
    "end\n",
    "\n",
    "    \n",
    "wlrec = [0.65, 0.8, 0.8, 0.9]\n",
    "input = wlrec[1]\n",
    "pred = neural_network(input,weights)\n",
    "\n",
    "print(pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Predicting with Multiple Inputs & Outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.555, 0.9800000000000001, 0.9650000000000001]"
     ]
    }
   ],
   "source": [
    "            #toes %win #fans\n",
    "weights = [ [0.1, 0.1, -0.3], #hurt?\n",
    "            [0.1, 0.2, 0.0], #win?\n",
    "            [0.0, 1.3, 0.1] ] #sad?\n",
    "\n",
    "function w_sum(a,b)\n",
    "    @assert length(a) == length(b)\n",
    "    output = 0\n",
    "    for i=1:length(a)\n",
    "        output += a[i] * b[i]\n",
    "    end\n",
    "    return output\n",
    "end\n",
    "\n",
    "function vect_mat_mul(vect, matrix)\n",
    "    @assert length(vect) == length(matrix)\n",
    "    output = [0.0, 0.0, 0.0]\n",
    "    for i=1:length(vect)\n",
    "        output[i] = w_sum(vect, matrix[i])\n",
    "    end\n",
    "    return output\n",
    "end\n",
    "\n",
    "function neural_network(input, weights)\n",
    "    pred = vect_mat_mul(input,weights)\n",
    "    return pred\n",
    "end\n",
    "\n",
    "\n",
    "\n",
    "# This dataset is the current\n",
    "# status at the beginning of\n",
    "# each game for the first 4 games\n",
    "# in a season.\n",
    "\n",
    "# toes = current number of toes\n",
    "# wlrec = current games won (percent)\n",
    "# nfans = fan count (in millions)\n",
    "\n",
    "toes =  [8.5, 9.5, 9.9, 9.0]\n",
    "wlrec = [0.65,0.8, 0.8, 0.9]\n",
    "nfans = [1.2, 1.3, 0.5, 1.0]\n",
    "\n",
    "# Input corresponds to every entry\n",
    "# for the first game of the season.\n",
    "\n",
    "input = [toes[1],wlrec[1],nfans[1]]\n",
    "pred = neural_network(input,weights)\n",
    "\n",
    "print(pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Predicting on Predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.21350000000000002, 0.14500000000000002, 0.5065]"
     ]
    }
   ],
   "source": [
    "            #toes %win #fans\n",
    "ih_wgt = [ [0.1, 0.2, -0.1], #hid[0]\n",
    "           [-0.1,0.1, 0.9], #hid[1]\n",
    "           [0.1, 0.4, 0.1] ] #hid[2]\n",
    "\n",
    "           #hid[0] hid[1] hid[2]\n",
    "hp_wgt = [ [0.3, 1.1, -0.3], #hurt?\n",
    "           [0.1, 0.2, 0.0], #win?\n",
    "           [0.0, 1.3, 0.1] ] #sad?\n",
    "\n",
    "weights = [ih_wgt, hp_wgt]\n",
    "\n",
    "function neural_network(input, weights)\n",
    "    hid = vect_mat_mul(input,weights[1])\n",
    "    pred = vect_mat_mul(hid,weights[2])\n",
    "    return pred\n",
    "end\n",
    "\n",
    "\n",
    "toes =  [8.5, 9.5, 9.9, 9.0]\n",
    "wlrec = [0.65,0.8, 0.8, 0.9]\n",
    "nfans = [1.2, 1.3, 0.5, 1.0]\n",
    "\n",
    "# Input corresponds to every entry\n",
    "# for the first game of the season.\n",
    "\n",
    "input = [toes[1],wlrec[1],nfans[1]]\n",
    "pred = neural_network(input,weights)\n",
    "\n",
    "print(pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Array Version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.0350000000000001 7.245000000000001 9.315]\n",
      "[1.0350000000000001 14.697000000000001 0.621]"
     ]
    }
   ],
   "source": [
    "#toes %win #fans\n",
    "ih_wgt = transpose([ \n",
    "            [0.1, 0.2, -0.1], #hid[0]\n",
    "            [-0.1,0.1, 0.9], #hid[1]\n",
    "            [0.1, 0.4, 0.1]]) #hid[2]\n",
    "\n",
    "\n",
    "# hid[0] hid[1] hid[2]\n",
    "hp_wgt = transpose([  \n",
    "            [0.3, 1.1, -0.3], #hurt?\n",
    "            [0.1, 0.2, 0.0], #win?\n",
    "            [0.0, 1.3, 0.1] ]) #sad?\n",
    "\n",
    "weights = [ih_wgt, hp_wgt]\n",
    "\n",
    "function neural_network(input, weights)\n",
    "    hid = sum(input .* weights[1])\n",
    "    println(hid)\n",
    "    pred = sum(hid .* weights[2])\n",
    "    return pred\n",
    "end\n",
    "\n",
    "\n",
    "toes =  [8.5, 9.5, 9.9, 9.0]\n",
    "wlrec = [0.65,0.8, 0.8, 0.9]\n",
    "nfans = [1.2, 1.3, 0.5, 1.0]\n",
    "\n",
    "input = [toes[1],wlrec[1],nfans[1]]\n",
    "\n",
    "pred = neural_network(input,weights)\n",
    "print(pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Primer on Julia Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3]\n",
      "[4, 5, 6, 7]\n",
      "[0 1 2 3; 4 5 6 7]\n",
      "[0.0 0.0 0.0 0.0; 0.0 0.0 0.0 0.0]\n",
      "[0.6257891065556151 0.17487653218454624 0.4920626037909861 0.8116905789872555 0.27502395998171236; 0.381777662483465 0.6598722305495173 0.4852067589888118 0.02102120216005665 0.08265635522654424]\n"
     ]
    }
   ],
   "source": [
    "using Random\n",
    "\n",
    "a = [0,1,2,3] # a vector\n",
    "b = [4,5,6,7] # another vector\n",
    "c = [0 1 2 3; # a matrix\n",
    "              4 5 6 7]\n",
    "\n",
    "d = zeros((2,4)) # (2x4 matrix of zeros)\n",
    "e = rand(2,5) # random 2x5\n",
    "# matrix with all numbers between 0 and 1\n",
    "\n",
    "println(a)\n",
    "println(b)\n",
    "println(c)\n",
    "println(d)\n",
    "println(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0, 0.1, 0.2, 0.30000000000000004]\n",
      "[0.0 0.2 0.4 0.6000000000000001; 0.8 1.0 1.2000000000000002 1.4000000000000001]\n",
      "[0, 5, 12, 21]\n",
      "[0.0, 1.0, 2.4000000000000004, 4.2]\n"
     ]
    },
    {
     "ename": "DimensionMismatch",
     "evalue": "DimensionMismatch(\"arrays could not be broadcast to a common size; got a dimension with lengths 4 and 2\")",
     "output_type": "error",
     "traceback": [
      "DimensionMismatch(\"arrays could not be broadcast to a common size; got a dimension with lengths 4 and 2\")",
      "",
      "Stacktrace:",
      " [1] _bcs1 at ./broadcast.jl:490 [inlined]",
      " [2] _bcs at ./broadcast.jl:484 [inlined]",
      " [3] broadcast_shape at ./broadcast.jl:478 [inlined]",
      " [4] combine_axes at ./broadcast.jl:473 [inlined]",
      " [5] instantiate at ./broadcast.jl:256 [inlined]",
      " [6] materialize(::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2},Nothing,typeof(*),Tuple{Array{Int64,1},Array{Int64,2}}}) at ./broadcast.jl:820",
      " [7] top-level scope at In[5]:8"
     ]
    }
   ],
   "source": [
    "println(a .* 0.1) # multiplies every number in vector \"a\" by 0.1\n",
    "      \n",
    "println(c .* 0.2) # multiplies every number in matrix \"c\" by 0.2\n",
    "      \n",
    "println(a .* b) # multiplies elementwise between a and b (columns paired up)\n",
    "      \n",
    "println(a .* b .* 0.2) # elementwise multiplication then multiplied by 0.2\n",
    "      \n",
    "println(a .* c) # since c has the same number of columns as a, this performs\n",
    "# elementwise multiplication on every row of the matrix \"c\"\n",
    "\n",
    "println(a * e) # since a and e don't have the same number of columns, this\n",
    "# throws a \"DimensionMismatch(\"arrays could not be broadcast to a common size; got a dimension with lengths 4 and 2\")\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 3)\n"
     ]
    }
   ],
   "source": [
    "a = zeros((1,4)) # vector of length 4\n",
    "b = zeros((4,3)) # matrix with 4 rows & 3 columns\n",
    "\n",
    "c = a * b\n",
    "println(size(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n",
      "(2, 3)\n",
      "(4, 6)\n"
     ]
    },
    {
     "ename": "DimensionMismatch",
     "evalue": "DimensionMismatch(\"A has dimensions (5,4) but B has dimensions (5,6)\")",
     "output_type": "error",
     "traceback": [
      "DimensionMismatch(\"A has dimensions (5,4) but B has dimensions (5,6)\")",
      "",
      "Stacktrace:",
      " [1] gemm_wrapper!(::Array{Float64,2}, ::Char, ::Char, ::Array{Float64,2}, ::Array{Float64,2}, ::LinearAlgebra.MulAddMul{true,true,Bool,Bool}) at /Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.4/LinearAlgebra/src/matmul.jl:569",
      " [2] mul! at /Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.4/LinearAlgebra/src/matmul.jl:169 [inlined]",
      " [3] mul! at /Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.4/LinearAlgebra/src/matmul.jl:208 [inlined]",
      " [4] *(::Array{Float64,2}, ::Array{Float64,2}) at /Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.4/LinearAlgebra/src/matmul.jl:160",
      " [5] top-level scope at In[21]:21"
     ]
    }
   ],
   "source": [
    "a = zeros((2,4)) # matrix with 2 rows and 4 columns\n",
    "b = zeros((4,3)) # matrix with 4 rows & 3 columns\n",
    "\n",
    "c = a * b\n",
    "println(size(c)) # outputs (2,3)\n",
    "\n",
    "e = zeros((2,1)) # matrix with 2 rows and 1 columns\n",
    "f = zeros((1,3)) # matrix with 1 row & 3 columns\n",
    "\n",
    "g = e * f\n",
    "println(size(g)) # outputs (2,3)\n",
    "\n",
    "h = transpose(zeros((5,4))) # matrix with 4 rows and 5 columns\n",
    "i = zeros((5,6)) # matrix with 6 rows & 5 columns\n",
    "\n",
    "j = h * i\n",
    "println(size(j)) # outputs (4,6)\n",
    "\n",
    "h = zeros((5,4)) # matrix with 5 rows and 4 columns\n",
    "i = zeros((5,6)) # matrix with 5 rows & 6 columns\n",
    "j = h * i\n",
    "println(size(j)) # throws an error"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.4.0",
   "language": "julia",
   "name": "julia-1.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.4.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}