First add

README.md

@@ -1,13 +1,11 @@
----
-title: CS772 ASSIGNMENT1
-emoji: 📚
-colorFrom: blue
-colorTo: gray
-sdk: streamlit
-sdk_version: 1.31.1
-app_file: app.py
-pinned: false
-license: mit
----
+# CS772-Assignment 1: Implementation of Backpropagation and Training a Palindrome Network
+1. Implement BP (using any existing tool/platform not allowed)
+2. Think of the correct architecture for Palindrome
+3. Train a feedforward n/w for solving the 10-bit palindrome problem (input- bit strings of 1 and 0); there will be 1024 input strings labeled 1 (if the string is Palindrome) and 0 (non-P)
+4. Train and Test using 4-fold cross-validation
+5. Measure Precision
+6. Find out what the hidden layer neurons are doing (VIMP)
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+### Insights
+1. Xoring input at opposing ends of input might work but since xoring operation is not linearly separable it cannot be done by one neuron

app.py

@@ -0,0 +1,51 @@
+import streamlit as st
+from mygrad import Layer, Value
+import pickle
+
+# Define the predict function
+def predict(x):
+    x1 = hiddenLayer1(x)    
+    final = outputLayer([x1] + x)
+    return final.data
+
+# Load model
+def loadModel():
+    neuron1weightsbias, outputneuronweightsbias = [], []
+    with open(f'parameters/neuron1weightsbias_fn_reLu.pckl', 'rb') as file:
+        neuron1weightsbias = pickle.load(file)
+    with open('parameters/outputneuronweightsbias2.pckl', 'rb') as file:
+        outputneuronweightsbias = pickle.load(file)
+    hiddenLayer1_ = Layer(10, 1, 'reLu')
+    outputLayer_ = Layer(11, 1, 'sigmoid')
+
+    hiddenLayer1_.neurons[0].w = [Value(i) for i in neuron1weightsbias[:-1]]
+    hiddenLayer1_.neurons[0].b = Value(neuron1weightsbias[-1])
+
+    outputLayer_.neurons[0].w = [Value(i) for i in outputneuronweightsbias[:-1]]
+    outputLayer_.neurons[0].b = Value(outputneuronweightsbias[-1])
+    return hiddenLayer1_, outputLayer_
+
+hiddenLayer1, outputLayer = loadModel()
+
+st.title("Neural Network Prediction")
+
+st.header("Input")
+inputs = st.text_input("Input 10 digits Binary no")
+input = []
+flag = 0
+if len(inputs)!=10:
+    st.write("Error: Input not equal to 10 bits")
+    flag =1
+for i in inputs:
+    if i!='0' and i!='1':
+        st.write("Please input Binary number only")
+        flag = 1
+    else:
+        input.append(int(i))
+
+# Prediction
+if st.button("Predict"):
+    if flag:
+        st.stop()
+    result = predict(input)
+    st.success(f"The prediction is: {result}")

mygrad.py

@@ -0,0 +1,262 @@
+import math
+import numpy as np
+import matplotlib.pyplot as plt
+import random
+from typing import Any
+
+def f(x):
+    return 3*x**2 + 2*x + 4
+
+def sigmoid(x):
+    return 1/(1+math.exp(-x))
+def modsigmoid(x):
+    return 2/(1+math.exp(abs(x)))
+
+
+class Value:
+
+    def __init__(self, data, _children = (), _op='', label = ''):
+        self.data = data
+        self.grad = 0.0 # represents derivative of the parent node with respec to current node
+        self._prev = set(_children)
+        self._backward = lambda: None
+        self._op = _op
+        self.label = label
+
+    def __repr__(self):
+        return f'Value(data={self.data})'
+
+    def __add__(self, other):
+        other = other if isinstance(other, Value) else Value(other)
+        out = Value(self.data+other.data, (self, other), '+')
+
+        def _backward():
+            self.grad += 1.0*out.grad  # out and self are addresses here, so if it gets executed in outer node then out == currentnode and self and other == children, so even if we are assigning a different address to out in current node, since out was used in this node, out will be current node when executing the function
+            other.grad += 1.0*out.grad
+        out._backward = _backward
+
+        return out
+    
+    def __mul__(self, other):
+        other = other if isinstance(other, Value) else Value(other)
+        out = Value(self.data*other.data, (self, other), '*')
+        def _backward():
+            self.grad += other.data*out.grad
+            other.grad += self.data*out.grad
+        out._backward = _backward
+        return out
+
+    def __pow__(self, other):
+        assert isinstance(other,(int, float))
+
+        out = Value(self.data**other, (self,), f'**{other}')
+
+        def _backward():
+            self.grad += other*(self.data**(other-1))*out.grad
+        out._backward = _backward
+        return out
+    
+    def __rmul__(self, other): # other*self
+        return self*other
+    
+    def __truediv__(self, other):
+        return self*other**-1
+    
+    def __neg__(self):
+        return self*-1
+
+    def __sub__(self, other):
+        return self + (-other)
+    
+    def __radd__(self, other):
+        return self + other
+
+    
+
+    def tanh(self):
+        x = self.data
+        t = (math.exp(2*x) - 1)/(math.exp(2*x) + 1)
+        out = Value(t, (self, ), 'tanh')
+        def _backward():
+            self.grad += (1 - t**2)*out.grad
+        out._backward = _backward
+        return out
+    def sin(self):
+        x = self.data
+        out = Value(math.sin(x), (self, ), 'sin')
+        def _backward():
+            self.grad += math.cos(x)*out.grad
+        out._backward = _backward
+        return out
+    def cos(self):
+        x = self.data
+        out = Value(math.cos(x), (self, ), 'cos')
+        def _backward():
+            self.grad += -math.sin(x)*out.grad
+        out._backward = _backward
+        return out
+    def tan(self):
+        x = self.data
+        out = Value(math.tan(x), (self, ), 'tan')
+        def _backward():
+            self.grad += (1/math.cos(x)**2)*out.grad
+        out._backward = _backward
+        return out
+    def cot(self):
+        x = self.data
+        out = Value(math.cot(x), (self, ), 'cot')
+        def _backward():
+            self.grad += -(1/math.sin(x)**2)*out.grad
+        out._backward = _backward
+        return out
+    def sinh(self):
+        x = self.data
+        out = Value(math.sinh(x), (self, ), 'sinh')
+        def _backward():
+            self.grad += math.cosh(x)*out.grad
+        out._backward = _backward
+        return out
+    def cosh(self):
+        x = self.data
+        out = Value(math.cosh(x), (self, ), 'sinh')
+        def _backward():
+            self.grad += math.sinh(x)*out.grad
+        out._backward = _backward
+        return out
+    
+
+    def exp(self):
+        x = self.data
+        out = Value(math.exp(x), (self,), 'exp')
+
+        def _backward():
+            self.grad += out.data*out.grad
+        out._backward = _backward
+        return out
+    def reLu(self):
+        x = self.data
+        out = Value(max(0, x), (self, ), 'reLu')
+        def _backward():
+            if x > 0:
+                self.grad += out.grad
+            else:
+                self.grad += 0
+        out._backward = _backward
+        return out
+    
+    def sigmoid(self):
+        x = self.data
+        s = sigmoid(x)
+        out = Value(s, (self,), 'sigmoid')
+
+        def _backward():
+            self.grad += s*(1 - s)*out.grad
+        out._backward = _backward
+        return out
+    def log(self):
+        x = self.data
+        # print(x)
+        out = Value(math.log(x), (self,), 'log')
+
+        def _backward():
+            self.grad += (1/x)*out.grad
+        out._backward = _backward
+        return out
+    
+    def modsigmoid(self):
+        x = self.data
+        s = modsigmoid(x)
+        out = Value(s, (self,), 'modsigmoid')
+
+        def _backward():
+            if x >= 0:
+                self.grad += -((2*x)/(x*(1+x)**2))*out.grad
+            else:
+                self.grad += -((2*x)/(-x*(1-x)**2))*out.grad
+
+        out._backward = _backward
+        return out
+        
+
+    def sinc(self):
+        if x == 0:
+            print('error 0 not valdid input')
+            return  
+        x = self.data
+        out = Value(math.sinx(x)/x, (self, ), 'sinc')
+        def _backward():
+            self.grad += ((2*x*math.sin(x) - (x**2)*math.cos(x))/(x**4))*out.grad
+        out._backward = _backward
+        return out
+        
+    def backward(self):
+        topo = []
+        visited = set()
+        def build_topo(v):
+            if v not in visited:
+              visited.add(v)
+              for child in v._prev:
+                build_topo(child)
+              topo.append(v)
+        build_topo(self)
+        self.grad = 1.0
+        for node in reversed(topo):
+            node._backward()
+class Neuron:
+    def __init__(self, nin, activation='sigmoid'):
+        self.w = [Value(random.uniform(-2, 2)) for _ in range(nin)]
+        self.b = Value(random.uniform(-2, 2))
+        self.activation = activation
+    
+    def parameters(self):
+        return self.w + [self.b]
+
+    def __call__(self, x): # Neuron()(x)
+
+        act = sum((xi*wi for xi, wi in zip(x, self.w)), self.b)
+        if self.activation == 'sigmoid':
+            out = act.sigmoid()
+        if self.activation == 'reLu':
+            out = act.reLu()
+        if self.activation == 'modsigmoid':
+            out = act.modsigmoid()
+        if self.activation == '':
+            return act
+        return out
+
+
+
+class Layer:
+    def __init__(self, nin, nout, activation='sigmoid'):
+        self.neurons = [Neuron(nin, activation=activation) for _ in range(nout)]
+    
+    def parameters(self):
+        return [p for neuron in self.neurons for p in neuron.parameters()]
+    def __call__(self, x):
+        outs = [n(x) for n in self.neurons]
+        return outs[0] if len(outs) == 1 else outs
+
+class MLP:
+    def __init__(self, nin, nouts):
+        sz = [nin] + nouts
+        self.layers = [Layer(sz[i], sz[i+1]) for i in range(len(nouts))]
+    def __call__(self, x):
+        for layer in self.layers:
+            x = layer(x)
+        return x
+    def parameters(self):
+        return [p for layer in self.layers for p in layer.parameters()]
+
+def fit(n, X, Y, epochs, learning_rate):
+    for k in range(epochs):
+        ypred = [n(x) for x in X]
+        loss = sum([(yout - ygt)**2 for ygt, yout in zip(Y, ypred)])
+        # resets all the grad to zero for our new weight and biases
+        for node in n.parameters():
+            node.grad = 0
+        # deposits all the gradients in the nodes
+        loss.backward()
+        # subtracts all the values by a fraction of gradient decent
+        for node in n.parameters():
+            node.data -= learning_rate*node.grad
+        # print(k, loss)

preparedata.ipynb

@@ -0,0 +1,161 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def checkPalindrome(number):\n",
+    "    number = str(number)\n",
+    "    l = 0\n",
+    "    r = len(number)-1\n",
+    "    while l < r:\n",
+    "        if number[l] != number[r]:\n",
+    "            return False\n",
+    "        l, r = l+1, r-1\n",
+    "    return True\n",
+    "\n",
+    "def generate_non_palindromic_numbers(count):\n",
+    "    palindromic_numbers = []\n",
+    "    i = 0\n",
+    "    while count > 0:\n",
+    "        binary_str = bin(i)[2:]  # Convert the index to binary\n",
+    "        # palindromic_number = '1' + binary_str + binary_str[::-1][1:] + '1'  # Create a palindromic number\n",
+    "        palindromic_number = binary_str\n",
+    "        palindromic_number = palindromic_number.zfill(10)\n",
+    "        if not checkPalindrome(palindromic_number):\n",
+    "            palindromic_numbers.append(str(palindromic_number))  # Ensure it's 10 digits long\n",
+    "            count -= 1\n",
+    "        i += 1\n",
+    "    return palindromic_numbers\n",
+    "\n",
+    "def generate_palindromic_numbers(count):\n",
+    "    palindromic_numbers = []\n",
+    "    i = 0\n",
+    "    while count > 0:\n",
+    "        binary_str = bin(i)[2:]  # Convert the index to binary\n",
+    "        # palindromic_number = '1' + binary_str + binary_str[::-1][1:] + '1'  # Create a palindromic number\n",
+    "        palindromic_number = binary_str\n",
+    "        palindromic_number = palindromic_number.zfill(10)\n",
+    "        if len(palindromic_number) > 10:\n",
+    "            print('all 10 digits palindromic numbers exhausted at', len(palindromic_numbers))\n",
+    "            return palindromic_numbers\n",
+    "        if checkPalindrome(palindromic_number):\n",
+    "            palindromic_numbers.append(str(palindromic_number))  # Ensure it's 10 digits long\n",
+    "            count -= 1\n",
+    "        i += 1\n",
+    "    return palindromic_numbers\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "all 10 digits palindromic numbers exhausted at 8\n"
+     ]
+    }
+   ],
+   "source": [
+    "data = generate_non_palindromic_numbers(512) + generate_palindromic_numbers(512)*16"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "label = []\n",
+    "for number in data:\n",
+    "    if checkPalindrome(number):\n",
+    "        label.append(1)\n",
+    "    else:\n",
+    "        label.append(0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "df = pd.DataFrame({'number':data, 'label':label})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pickle\n",
+    "with open('data6dig.pckl', 'wb') as file:\n",
+    "    pickle.dump(df, file)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df.to_csv('data.csv')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(512, 512)"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "label.count(0), label.count(1)"
+   ]
+  },
+  {
+   "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.11.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

usethistocheckaccuracywotraingin.ipynb

@@ -0,0 +1,148 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from mygrad import Layer\n",
+    "from mygrad import Value\n",
+    "import pickle\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def predict(x):\n",
+    "    x1 = hiddenLayer1(x)    \n",
+    "    final = outputLayer([x1] + x)\n",
+    "    return final"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.metrics import accuracy_score, precision_score, f1_score, recall_score\n",
+    "def getAccuracy(X, Y):\n",
+    "    predicted = [1 if predict(x).data > 0.5 else 0 for x in X ]\n",
+    "    return accuracy_score(Y, predicted)\n",
+    "def getPrecision(X, Y):\n",
+    "    predicted = [1 if predict(x).data > 0.5 else 0 for x in X ]\n",
+    "    return precision_score(Y, predicted)\n",
+    "def getf1(X, Y):\n",
+    "    predicted = [1 if predict(x).data > 0.5 else 0 for x in X ]\n",
+    "    return f1_score(Y, predicted)\n",
+    "def getRecall(X, Y):\n",
+    "    predicted = [1 if predict(x).data > 0.5 else 0 for x in X ]\n",
+    "    return recall_score(Y, predicted)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load model\n",
+    "\n",
+    "def loadModel():\n",
+    "    neuron1weightsbias, outputneuronweightsbias = [], []\n",
+    "    with open(f'parameters/neuron1weightsbias_fn_reLu.pckl', 'rb') as file:\n",
+    "        neuron1weightsbias = pickle.load(file)\n",
+    "    with open('parameters/outputneuronweightsbias_fn_reLu.pckl', 'rb') as file:\n",
+    "        outputneuronweightsbias = pickle.load(file)\n",
+    "    hiddenLayer1_ = Layer(10, 1, 'reLu')\n",
+    "    outputLayer_ = Layer(11, 1, 'sigmoid')\n",
+    "\n",
+    "    hiddenLayer1_.neurons[0].w = [Value(i) for i in neuron1weightsbias[:-1]]\n",
+    "    hiddenLayer1_.neurons[0].b = Value(neuron1weightsbias[-1])\n",
+    "\n",
+    "    outputLayer_.neurons[0].w = [Value(i) for i in outputneuronweightsbias[:-1]]\n",
+    "    outputLayer_.neurons[0].b = Value(outputneuronweightsbias[-1])\n",
+    "    return hiddenLayer1_, outputLayer_, neuron1weightsbias, outputneuronweightsbias"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hiddenLayer1, outputLayer, neuron1weightsbias, outputneuronweightsbias = loadModel()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pickle\n",
+    "with open('data.pckl', 'rb') as file:\n",
+    "    data = pickle.load(file)\n",
+    "from sklearn.utils import shuffle\n",
+    "data = shuffle(data)\n",
+    "X = [list(number) for number in data['number']]\n",
+    "Y = [label for label in data['label']]\n",
+    "for ix, row in enumerate(X):\n",
+    "    X[ix] = [Value(float(item)) for item in row]\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.9609375"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "getAccuracy(X, Y)\n"
+   ]
+  },
+  {
+   "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.11.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}