Perceptron_Algorithm_NN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "067b1f1a",
   "metadata": {},
   "source": [
    "# Perceptron Algorithm single layer neural network \n",
    " the following code for found outputs for all Gates , training and testing \n",
    "- ### [ AND Gate , NAND Gate , NOR Gate ,OR Gate ]\n",
    "- ### [AND NOT Gate , NOT AND Gate]\n",
    "- ### [OR NOT Gate , NOT OR Gate ]\n",
    "\n",
    "you need install extension [Markdown Preview ](https://marketplace.visualstudio.com/items?itemName=bierner.markdown-preview-github-styles) for edit and preview .md file or Markdown files  \n",
    "all outputs save in outputs folder as md file as table if you want that or show output in print()\n",
    "* [Taiz university](https://taiz.edu.ye/en/default.ASPX) - Software Engineering  \n",
    "    by : [Rafiq7M](https://github.com/Rafiq7M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "4d523d0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "3b1f4969",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# sigmoid activation function \n",
    "def sigmoid(z):\n",
    "    return (1/(1+np.exp(-z)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "feb0682c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_training_inputs(gateName='or',b=1):\n",
    "    if gateName.lower()=='and':\n",
    "        # training Inputs\n",
    "        #  # AND Gate\n",
    "        x=np.array([\n",
    "            [1 ,1 , b],\n",
    "            [1 ,-1 , b],\n",
    "            [-1 ,1 , b],\n",
    "            [-1 ,-1 , b]])\n",
    "        t=np.array([1,-1,-1,-1])\n",
    "    elif gateName.lower()=='nand':\n",
    "        #  # NAND Gate\n",
    "        x=np.array([\n",
    "            [1 ,1 , b],\n",
    "            [1 ,-1 , b],\n",
    "            [-1 ,1 , b],\n",
    "            [-1 ,-1 , b]])\n",
    "        t=np.array([-1,1,1,1])\n",
    "\n",
    "    elif gateName.lower()=='or':\n",
    "        #  # OR Gate\n",
    "        x=np.array([\n",
    "            [1 ,1 , b],\n",
    "            [1 ,-1 , b],\n",
    "            [-1 ,1 , b],\n",
    "            [-1 ,-1 , b]])\n",
    "        t=np.array([1,1,1,-1])\n",
    "    elif gateName.lower()=='nor':\n",
    "        #  # NOR Gate\n",
    "        x=np.array([\n",
    "            [1 ,1 , b],\n",
    "            [1 ,-1 , b],\n",
    "            [-1 ,1 , b],\n",
    "            [-1 ,-1 ,b]])\n",
    "        t=np.array([-1,-1,-1,1])\n",
    "    elif gateName.lower()=='and_not':\n",
    "        #  # AND NOT Gate\n",
    "        x=np.array([\n",
    "            [1 ,1 , b],\n",
    "            [1 ,-1 , b],\n",
    "            [-1 ,1 , b],\n",
    "            [-1 ,-1 ,b]])\n",
    "        t=np.array([-1,1,-1,-1])\n",
    "        \n",
    "    elif gateName.lower()=='not_and':\n",
    "        #  # NOT AND Gate\n",
    "        x=np.array([\n",
    "            [1 ,1 , b],\n",
    "            [1 ,-1 , b],\n",
    "            [-1 ,1 , b],\n",
    "            [-1 ,-1 ,b]])\n",
    "        t=np.array([-1,-1,1,-1])\n",
    "        \n",
    "    elif gateName.lower()=='or_not':\n",
    "        #  # OR NOT Gate\n",
    "        x=np.array([\n",
    "            [1 ,1 , b],\n",
    "            [1 ,-1 , b],\n",
    "            [-1 ,1 , b],\n",
    "            [-1 ,-1 ,b]])\n",
    "        t=np.array([1,1,-1,1])\n",
    "    elif gateName.lower()=='not_or':\n",
    "        #  # NOT OR Gate\n",
    "        x=np.array([\n",
    "            [1 ,1 , b],\n",
    "            [1 ,-1 , b],\n",
    "            [-1 ,1 , b],\n",
    "            [-1 ,-1 ,b]])\n",
    "        t=np.array([1,-1,1,1])\n",
    "    return x,t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "44e68c95",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x= \n",
      " [[ 1  1  0]\n",
      " [ 1 -1  0]\n",
      " [-1  1  0]\n",
      " [-1 -1  0]]\n",
      "t= \n",
      " [ 1 -1 -1 -1]\n"
     ]
    }
   ],
   "source": [
    "batch=8 #2 iterations\n",
    "w=np.array([0,0,0]) # initialize weight and bias \n",
    "th=0.2\n",
    "b=0\n",
    "gateName='AND'\n",
    "x,t=get_training_inputs(gateName,b)\n",
    "title=f\"{gateName} Gate \\n ## with ({batch}) batch , and ({w},{b}) init weights , bias \"\n",
    "print(\"x= \\n\",x)\n",
    "print(\"t= \\n\",t)\n",
    "\n",
    "current_date = datetime.datetime.now().strftime(\"%Y-%m-%d\")\n",
    "# filename = f\"outputs/{title}_outputs_table_{current_date}.md\"\n",
    "filename = f\"outputs/{gateName} Gate outputs.md\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "2bb20556",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Write the mdText to a file\n",
    "def save_outputs_md_file(filepath,mode,mdText,title):\n",
    "    mdText+=\"\\n---\\n\"\n",
    "    initText=f\"# {title} \\n\"\n",
    "    with open(filepath, mode) as mdFile:\n",
    "        by=\"\\n\\n- By: [Rafiq7M](https://github.com/Rafiq7M)\\n\"\n",
    "        mdFile.write(initText+mdText+by)\n",
    "    print(f\"Output table saved in {filepath}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "015a99cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def perceptron_learning(x,t,batch,w,th):\n",
    "    mdText = \"\"\n",
    "    for i in range(batch):\n",
    "        batch_x=x\n",
    "        count=i%4\n",
    "    # calculate net\n",
    "        net1=np.sum(batch_x[count]*w.T)\n",
    "        out=net1\n",
    "\n",
    "        # when theta =0.2\n",
    "        if out>=th :\n",
    "            out =1\n",
    "        if (out<th )and(out>-th) :\n",
    "            out =0\n",
    "        if out<=-th :\n",
    "            out =-1\n",
    "\n",
    "        if out == t[count]:\n",
    "            xdelta=[0,0,0]\n",
    "            out_str=\"✅\" #\"🟢\"\n",
    "        else :\n",
    "            xdelta=t[count]*batch_x[count]\n",
    "            out_str=\"❌\"  #\"🔴\"\n",
    "        w=np.add(w,xdelta)\n",
    "        \n",
    "        # print outputs table\n",
    "        x_str = ', '.join(map(str, x[count]))\n",
    "        t_str = ', '.join(map(str, [t[count]]))\n",
    "        xdelta_str = ', '.join(map(str, xdelta))\n",
    "        w_str = ', '.join(map(str, w))\n",
    "        if (count==0) : \n",
    "            mdText += f\"\\n### 🌐 Iteration {(i // 4) + 1}\\n\\n\"\n",
    "            mdText += f\"| {'i'} | {'count'} | {'inputs Xi'} | {'net1'} | {'out'} | {'target'} | {'Delta '} | {'WEIGHTS'} |\\n\"\n",
    "            mdText += \"|---|---|---|---|---|---|---|---|\\n\"\n",
    "        \n",
    "            print(f\"iteration={(i/4)+1}\")\n",
    "            print(f'{\"i\":^2} {\"count\":^2}  {\"INPUT\":^15} {\"net1\":^5}  {\"out\":^5} {\"TARGET\":^10} {\"Delta\":^15} {\"WEIGHTS\":^15} ')\n",
    "            print(\"==\"*45)\n",
    "           \n",
    "        mdText += f'| {i} | {count} | {x_str} | {net1} | {out} {out_str}| {t_str} | {xdelta_str} | {w_str} |\\n'\n",
    "        \n",
    "        print(f'{i} {x_str:^20} {net1:^2} {out} {out_str:^12} {t_str:^1} {xdelta_str:^24} {w_str:10}')\n",
    "        print()\n",
    "    \n",
    "    # \n",
    "    mdText += f\"\\n## Final weights = {w_str}\\n\"\n",
    "    mdText += \"\\n\"\n",
    "    \n",
    "    print(f\"\\n## Final  weights = {w_str}\\n\")\n",
    "    \n",
    "    return w,mdText\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "73c546cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# test function      \n",
    "def test_NN (x,t,w):\n",
    "    mdText =\"\\n\"\n",
    "    def test_NN (z):\n",
    "        return np.dot(z,w)\n",
    "    mdText += f\"| 'i' |'inputs Wi' |'target' | 'output' |💱|\\n\"\n",
    "    mdText += \"|---|---|---|---|---|\\n\"\n",
    "    \n",
    "    \n",
    "    print(f\"\\n## Testing\\n\")\n",
    "    print(f'{\"i\":^2} {\"INPUT\":^15} {\"TARGET\":^10} {\"output\":^10}')\n",
    "        \n",
    "    for x_i in range(len(x)):\n",
    "        x_str = ', '.join(map(str, x[x_i]))\n",
    "        t_str = ', '.join(map(str, [t[x_i]]))\n",
    "        out=2*int(round(sigmoid(test_NN(x[x_i]))))-1\n",
    "        if out == t[x_i]:\n",
    "            out_str=\"✅\" #\"🟢\"\n",
    "        else :\n",
    "            out_str=\"❌\"  #\"🔴\"\n",
    "                        \n",
    "        mdText += f'| {x_i} | {x_str} | {t_str} | {out}|{out_str}|\\n'\n",
    "        print(f'{x_i} {x_str:^20} {t_str:^1}  {out} {out_str:^10}')\n",
    "\n",
    "\n",
    "    return mdText\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e50b9b0d",
   "metadata": {},
   "source": [
    "## Pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "e099ac31",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration=1.0\n",
      "i  count       INPUT      net1    out    TARGET        Delta          WEIGHTS     \n",
      "==========================================================================================\n",
      "0       1, 1, 0        0  0      ❌       1         1, 1, 0          1, 1, 0   \n",
      "\n",
      "1       1, -1, 0       0  0      ❌       -1         -1, 1, 0         0, 2, 0   \n",
      "\n",
      "2       -1, 1, 0       2  1      ❌       -1         1, -1, 0         1, 1, 0   \n",
      "\n",
      "3      -1, -1, 0       -2 -1      ✅       -1         0, 0, 0          1, 1, 0   \n",
      "\n",
      "iteration=2.0\n",
      "i  count       INPUT      net1    out    TARGET        Delta          WEIGHTS     \n",
      "==========================================================================================\n",
      "4       1, 1, 0        2  1      ✅       1         0, 0, 0          1, 1, 0   \n",
      "\n",
      "5       1, -1, 0       0  0      ❌       -1         -1, 1, 0         0, 2, 0   \n",
      "\n",
      "6       -1, 1, 0       2  1      ❌       -1         1, -1, 0         1, 1, 0   \n",
      "\n",
      "7      -1, -1, 0       -2 -1      ✅       -1         0, 0, 0          1, 1, 0   \n",
      "\n",
      "\n",
      "## Final  weights = 1, 1, 0\n",
      "\n",
      "Output table saved in outputs/AND Gate outputs.md\n",
      "done ✅\n"
     ]
    }
   ],
   "source": [
    "\n",
    "final_weights,output_md_text=perceptron_learning(x,t,batch,w,th)\n",
    "save_outputs_md_file(filename,'w',output_md_text,title)\n",
    "print(\"done ✅\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4eeb8ab7",
   "metadata": {},
   "source": [
    "## Testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "4149cacd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "## Testing\n",
      "\n",
      "i       INPUT        TARGET     output  \n",
      "0       1, 1, 0        1  1     ✅     \n",
      "1       1, -1, 0       -1  -1     ✅     \n",
      "2       -1, 1, 0       -1  -1     ✅     \n",
      "3      -1, -1, 0       -1  -1     ✅     \n",
      "Output table saved in outputs/AND Gate outputs.md\n",
      "done ✅\n"
     ]
    }
   ],
   "source": [
    "output_md_text=test_NN(x,t,final_weights)\n",
    "save_outputs_md_file(filename,'a',output_md_text,\"Testing \"+title)\n",
    "print(\"done ✅\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}