00-logic_neuron_programming.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Code your own neuron and neural net\n",
    "The parts of code that look like\n",
    "```python\n",
    "pass  # ⬅️✏️\n",
    "```\n",
    "need to be filled in before moving to the next cell.\n",
    "\n",
    "Check out the slides and / or corresponding video lecture for more instructions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "lines_to_next_cell": 1
   },
   "outputs": [],
   "source": [
    "# Define two vectors (lists): input my_x, weights my_w\n",
    "my_x = [0, 1, 1]\n",
    "my_w = [-10, 10, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiply two lists element wise\n",
    "def mul(a, b):\n",
    "    \"\"\"\n",
    "    return a list c, same length as a, element c[i] = a[i] * b[i]\n",
    "    \"len(list)\" and \"[0] * n\" may be useful\n",
    "    \"\"\"\n",
    "    c = [a_i * b_i for a_i, b_i in zip(a, b)]\n",
    "    return c"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 10, 5]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test mul() function\n",
    "mul(my_x, my_w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "lines_to_next_cell": 1
   },
   "outputs": [],
   "source": [
    "# Define a scalar: bias b\n",
    "my_b = -5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Neuron linear (internal) potential\n",
    "def linear_neuron(x, weights, bias):\n",
    "    \"\"\"\n",
    "    return a scalar value representing a scalar neuron\n",
    "    \"sum(list)\" computes the sum of the elements in a list\n",
    "    \"\"\"\n",
    "    return sum(mul(x, weights)) + bias"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test linear_neuron() function\n",
    "linear_neuron(my_x, my_w, my_b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "lines_to_next_cell": 1
   },
   "outputs": [],
   "source": [
    "# Import exp() function (safe on lists)\n",
    "from numpy import exp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Logistic sigmoid\n",
    "def sigmoid(z):\n",
    "    \"\"\"\n",
    "    return the logistic sigmoid (use exp())\n",
    "    \"\"\"\n",
    "    return 1 / (1 + exp(-z))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0066928509242848554\n",
      "0.5\n",
      "0.9933071490757153\n"
     ]
    }
   ],
   "source": [
    "# Try out σ() for different z values\n",
    "for z in (-5, 0, 5): print(sigmoid(z))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import some plotting stuff to graph sigmoid()\n",
    "from numpy import linspace\n",
    "from matplotlib.pyplot import plot, axhline, axvline, grid, style\n",
    "style.use('dark_background')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Get a pair of axis and grid lines centred in (0, 0)\n",
    "axhline(c='.2'); axvline(color='.2')\n",
    "grid(c='.1', ls='--')\n",
    "\n",
    "# Plot across a span of numbers\n",
    "z = linspace(-7.5, 7.5)\n",
    "plot(z, sigmoid(z));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Full neuron function\n",
    "def neuron(x, weights, bias):\n",
    "    \"\"\"\n",
    "    Return a classical neuron output (reuse code above)\n",
    "    \"\"\"\n",
    "    return sigmoid(linear_neuron(x, weights, bias))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9999546021312976"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test neuron() function\n",
    "neuron(my_x, my_w, my_b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "lines_to_next_cell": 1
   },
   "outputs": [],
   "source": [
    "# Package OR neuron weights and bias\n",
    "def or_neuron(x):\n",
    "    \"\"\"\n",
    "    Return x1 OR x2 (x1 + x2)\n",
    "    \"\"\"\n",
    "    return int(x[0] or x[1])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defina a collection of inputs to test OR and AND\n",
    "my_x_collection = [\n",
    "    [0, 0],\n",
    "    [0, 1],\n",
    "    [1, 0],\n",
    "    [1, 1],\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "lines_to_next_cell": 1
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Checking OR neuron output\n",
      "[0, 0] 0.000\n",
      "[0, 1] 1.000\n",
      "[1, 0] 1.000\n",
      "[1, 1] 1.000\n"
     ]
    }
   ],
   "source": [
    "print('Checking OR neuron output')\n",
    "for my_x in my_x_collection:\n",
    "    print(my_x, f'{or_neuron(my_x):.3f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "lines_to_next_cell": 1
   },
   "outputs": [],
   "source": [
    "# Package AND neuron weights and bias\n",
    "def and_neuron(x):\n",
    "    \"\"\"\n",
    "    Return x1 AND x2 (x1 * x2)\n",
    "    \"\"\"\n",
    "    return int(x[0] and x[1])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "lines_to_next_cell": 1
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Checking AND neuron output\n",
      "[0, 0] 0.000\n",
      "[0, 1] 0.000\n",
      "[1, 0] 0.000\n",
      "[1, 1] 1.000\n"
     ]
    }
   ],
   "source": [
    "print('Checking AND neuron output')\n",
    "for my_x in my_x_collection:\n",
    "    print(my_x, f'{and_neuron(my_x):.3f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "lines_to_next_cell": 1
   },
   "outputs": [],
   "source": [
    "# Package NOT neuron weight and bias\n",
    "def not_neuron(x):\n",
    "    \"\"\"\n",
    "    Return NOT x1 (x1_)\n",
    "    \"\"\"\n",
    "    return int(not x[0])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "lines_to_next_cell": 1
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Checking NOT neuron output\n",
      "[0] 1.000\n",
      "[1] 0.000\n"
     ]
    }
   ],
   "source": [
    "print('Checking NOT neuron output')\n",
    "for my_x in [[0], [1]]:\n",
    "    print(my_x, f'{not_neuron(my_x):.3f}')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![X-OR](res/x-or_circuit.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Combine OR, AND, and NOT into a XOR neuron\n",
    "def xor_neuron(x):\n",
    "    \"\"\"\n",
    "    Return x1_ * x2 + x1 * x2_\n",
    "    \"\"\"\n",
    "    x1 = x[0]\n",
    "    x2 = x[1]\n",
    "    \n",
    "    not_x1 = not_neuron([x1])\n",
    "    not_x2 = not_neuron([x2])\n",
    "\n",
    "    not_x1_and_x2 = and_neuron([not_x1, x2])\n",
    "    x1_and_not_x2 = and_neuron([x1, not_x2])\n",
    "\n",
    "    return or_neuron([not_x1_and_x2, x1_and_not_x2])\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Checking XOR neuron output\n",
      "[0, 0] 0.000\n",
      "[0, 1] 1.000\n",
      "[1, 0] 1.000\n",
      "[1, 1] 0.000\n"
     ]
    }
   ],
   "source": [
    "print('Checking XOR neuron output')\n",
    "for my_x in my_x_collection:\n",
    "    print(my_x, f'{xor_neuron(my_x):.3f}')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Half-adder](res/half-adder_circuit.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Combine a XOR and an AND into a half-adder\n",
    "def half_adder(x):\n",
    "    Sum = xor_neuron(x)\n",
    "    Carry = and_neuron(x)\n",
    "    return Sum, Carry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input: [0, 0] Sum: 0.000, Carry: 0.000\n",
      "Input: [0, 1] Sum: 1.000, Carry: 0.000\n",
      "Input: [1, 0] Sum: 1.000, Carry: 0.000\n",
      "Input: [1, 1] Sum: 0.000, Carry: 1.000\n"
     ]
    }
   ],
   "source": [
    "for my_x in my_x_collection:\n",
    "    Sum, Carry = half_adder(my_x)\n",
    "    print(f\"Input: {my_x}\", f'Sum: {Sum:.3f}, Carry: {Carry:.3f}')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Adder](res/adder_circuit.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Combine two half-adders and an OR into a (full) adder\n",
    "# ⬅️✏️\n",
    "from operator import itemgetter\n",
    "\n",
    "def adder(x):\n",
    "    x_AB = list(itemgetter(0, 1)(x))\n",
    "    C_in = x[-1]\n",
    "    Sum_0, Carry_0 = half_adder(x_AB)\n",
    "    Sum_1, Carry_1 = half_adder([Sum_0, C_in])\n",
    "    C_out = or_neuron([Carry_0, Carry_1])\n",
    "\n",
    "    return Sum_1, C_out\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 0, 0]: adder result: (0, 0)\n",
      "[0, 0, 1]: adder result: (1, 0)\n",
      "[0, 1, 0]: adder result: (1, 0)\n",
      "[0, 1, 1]: adder result: (0, 1)\n",
      "[1, 0, 0]: adder result: (1, 0)\n",
      "[1, 0, 1]: adder result: (0, 1)\n",
      "[1, 1, 0]: adder result: (0, 1)\n",
      "[1, 1, 1]: adder result: (1, 1)\n"
     ]
    }
   ],
   "source": [
    "my_x_collection = [\n",
    "    [0, 0, 0],\n",
    "    [0, 0, 1],\n",
    "    [0, 1, 0],\n",
    "    [0, 1, 1],\n",
    "    [1, 0, 0],\n",
    "    [1, 0, 1],\n",
    "    [1, 1, 0],\n",
    "    [1, 1, 1]\n",
    "]\n",
    "\n",
    "for x in my_x_collection:\n",
    "    print(f\"{x}: adder result: {adder(x)}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "encoding": "# -*- coding: utf-8 -*-"
  },
  "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.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}