Fixed minor bugs. Fixed the Ui parameters to be more easy to train.

app.py

@@ -1,46 +1,77 @@
 import streamlit as st
+from nn import NeuralNetwork
 import json
-from nn import train, predict, save_model, sigmoid
-
-# INPUTS = [[0,0],[0,1],[1,0],[1,1]]
-# OUTPUTS = [[0],[1],[1],[0]]
-# EPOCHS = 1000000
-# ALPHAS = 20
+from utils import sigmoid, sigmoid_prime
 
 INPUTS = [[0,0],[0,1],[1,0],[1,1]]
 OUTPUTS = [[0],[1],[1],[0]]
 
-def runNN(epoch, alpha):
-    # Train model
-    modelo = train(epochs=epoch, alpha=alpha)
-    print(modelo)
-    # Save model to file
-    # save_model(modelo, "modelo.json")
-    st.download_button(
-        label="Download model",
-        data=json.dumps(modelo),
-        file_name="modelo.json",
-        mime="application/json",
-    )
+def resetSession():
+    st.session_state.nn = None
+    st.session_state.train_count = 0
 
+## Controller Function
+def runNN():
+    nn = st.session_state.nn
+    df = {
+        "input": [],
+        "expected": [],
+        "predicted": [],
+        "rounded": [],
+        "correct": []
+    }
     for i in range(4):
-        result = predict(INPUTS[i][0],INPUTS[i][1], activation=sigmoid)
-        st.write("for input", INPUTS[i], "expected", OUTPUTS[i][0], "predicted", f"{result:4.4}", "which is", "correct" if round(result)==OUTPUTS[i][0] else "incorrect")
-        
+        result = nn.predict(INPUTS[i][0],INPUTS[i][1], activation=sigmoid)
+        df["input"].append(f"{INPUTS[i][0]} xor {INPUTS[i][1]}")
+        df["expected"].append(OUTPUTS[i][0])
+        df["predicted"].append(result)
+        df["rounded"].append(round(result))
+        df["correct"].append('correct' if round(result)==OUTPUTS[i][0] else 'incorrect')
 
+    st.dataframe(df)
+        # st.write(f"for input `{INPUTS[i][0]} xor {INPUTS[i][1]}` expected `{OUTPUTS[i][0]}` predicted `{result}` which rounds to `{round(result)}` and is `{ 'correct' if round(result)==OUTPUTS[i][0] else 'incorrect' }`")
+        
 
 def sidebar():
     # Neural network controls
     st.sidebar.header('Neural Network Controls')
     st.sidebar.text('Number of epochs')
-    epochs = st.sidebar.slider('Epochs', 1000, 1000000, 100000)
+    epochs = st.sidebar.slider('Epochs', 1, 10000, 500)
     st.sidebar.text('Learning rate')
     alphas = st.sidebar.slider('Alphas', 1, 100, 20)
-    if st.sidebar.button('Run Neural Network'):
-        runNN(epochs, alphas)
+    col1, col2 = st.sidebar.columns(2)
+    if col1.button('New Model'):
+        btnNewModel()
+
+    if col2.button('Reset Model'):
+        resetSession()
+
+    if "nn" in st.session_state and st.session_state.nn is not None:
+        if st.sidebar.button('Train Model'):
+            btnTrainModel(epochs, alphas)
+        if st.sidebar.button('Run Neural Network'):
+            btnRunModel()
+        st.sidebar.download_button(label="Save Model", data=json.dumps(st.session_state.nn.getModelJson()), file_name="model.json", mime="application/json")
+
+def btnNewModel():
+    resetSession()
+    st.session_state.nn = NeuralNetwork()
+    st.sidebar.text("New model created")
+
+def btnTrainModel(epochs, alphas):
+    st.session_state.nn.train(inputs=INPUTS, outputs=OUTPUTS, epochs=epochs, alpha=alphas)
+    st.session_state.train_count += 1
+    st.sidebar.text(f"Model trained {st.session_state.train_count} times")
+
+def btnRunModel():
+    runNN()
 
+def btnResetModel():
+    resetSession()
+    st.sidebar.text("Model reset")
 
 def app():
+    # initSession()
     st.title('Simple Neural Network App')
     st.write('This is the Neural Network image we are trying to implement!')
     st.image('nn.png', width=500)

nn.py

@@ -1,196 +1,144 @@
 import random
-import math
 import json
+from typing import Any
+from utils import sigmoid, sigmoid_prime
 
-INPUTS = [[0,0],[0,1],[1,0],[1,1]]
-OUTPUTS = [[0],[1],[1],[0]]
 EPOCHS = 1000000
 ALPHAS = 20
 
-
 WEPOCHS = EPOCHS // 100
-
-
 VARIANCE_W = 0.5
-VARIANCE_B = 0
-
-w11 = random.uniform(-VARIANCE_W,VARIANCE_W)
-w21 = random.uniform(-VARIANCE_W,VARIANCE_W)
-b1 = VARIANCE_B
-
-w12 = random.uniform(-VARIANCE_W,VARIANCE_W)
-w22 = random.uniform(-VARIANCE_W,VARIANCE_W)
-b2 = VARIANCE_B
-
-w13 = random.uniform(-VARIANCE_W,VARIANCE_W)
-w23 = random.uniform(-VARIANCE_W,VARIANCE_W)
-b3 = VARIANCE_B
-
-o1 = random.uniform(-VARIANCE_W,VARIANCE_W)
-o2 = random.uniform(-VARIANCE_W,VARIANCE_W)
-o3 = random.uniform(-VARIANCE_W,VARIANCE_W)
-ob = VARIANCE_B
-
-## Tudo a 0.5
-# VARIANCE_W = 0.5
-# VARIANCE_B = 1
-# w11 = VARIANCE_W
-# w21 = VARIANCE_W
-# b1 = VARIANCE_B
-
-# w12 = VARIANCE_W
-# w22 = VARIANCE_W
-# b2 = VARIANCE_B
-
-# w13 = VARIANCE_W
-# w23 = VARIANCE_W
-# b3 = VARIANCE_B
-
-# o1 = VARIANCE_W
-# o2 = VARIANCE_W
-# o3 = VARIANCE_W
-# ob = VARIANCE_B
-
-
-def sigmoid(x):
-    return 1.0 / (1.0 + math.exp(-x))
-
-
-def sigmoid_prime(x): # x already sigmoided
-    return x * (1 - x)
-
-def relu(x):
-    return max(0,x)
-
-def relu_prime(x):
-    return 1 if x>0 else 0
-
-def tanh(x):
-    return math.tanh(x)
-
-def tanh_prime(x):
-    return 1 - x**2
-
-def softmax(x):
-    return math.exp(x) / (math.exp(x) + 1)
-
-def softmax_prime(x):
-    return x * (1 - x)
-
-def predict(i1, i2, activation=sigmoid):    
-    s1 = w11 * i1 + w21 * i2 + b1
-    # s1 = sigmoid(s1)
-    s1 = activation(s1)
-    s2 = w12 * i1 + w22 * i2 + b2
-    # s2 = sigmoid(s2)
-    s2 = activation(s2)
-    s3 = w13 * i1 + w23 * i2 + b3
-    # s3 = sigmoid(s3)
-    s3 = activation(s3)
+VARIANCE_B = 1
+
+class NeuralNetwork:
+    def __init__(self):
+        self._w11 = random.uniform(-VARIANCE_W,VARIANCE_W)
+        self._w21 = random.uniform(-VARIANCE_W,VARIANCE_W)
+        self._b1 = VARIANCE_B
+
+        self._w12 = random.uniform(-VARIANCE_W,VARIANCE_W)
+        self._w22 = random.uniform(-VARIANCE_W,VARIANCE_W)
+        self._b2 = VARIANCE_B
+
+        self._w13 = random.uniform(-VARIANCE_W,VARIANCE_W)
+        self._w23 = random.uniform(-VARIANCE_W,VARIANCE_W)
+        self._b3 = VARIANCE_B
+
+        self._o1 = random.uniform(-VARIANCE_W,VARIANCE_W)
+        self._o2 = random.uniform(-VARIANCE_W,VARIANCE_W)
+        self._o3 = random.uniform(-VARIANCE_W,VARIANCE_W)
+        self._ob = VARIANCE_B
     
-    output = s1 * o1 + s2 * o2 + s3 * o3 + ob
-    # output = sigmoid(output)
-    output = activation(output)
-    
-    return output
+    def predict(self, i1, i2, activation=sigmoid):    
+        s1 = self._w11 * i1 + self._w21 * i2 + self._b1
+        s1 = activation(s1)
+        s2 = self._w12 * i1 + self._w22 * i2 + self._b2
+        s2 = activation(s2)
+        s3 = self._w13 * i1 + self._w23 * i2 + self._b3
+        s3 = activation(s3)
+        
+        output = s1 * self._o1 + s2 * self._o2 + s3 * self._o3 + self._ob
+        output = activation(output)
+        
+        return output
 
 
-def learn(i1,i2,target, activation, activation_prime, alpha=0.2):
-    global w11,w21,b1,w12,w22,b2,w13,w23,b3
-    global o1,o2,o3,ob
-    
-    s1 = w11 * i1 + w21 * i2 + b1
-    # s1 = sigmoid(s1)
-    s1 = activation(s1)
-    s2 = w12 * i1 + w22 * i2 + b2
-    # s2 = sigmoid(s2)
-    s2 = activation(s2)
-    s3 = w13 * i1 + w23 * i2 + b3
-    # s3 = sigmoid(s3)
-    s3 = activation(s3)
-    
-    output = s1 * o1 + s2 * o2 + s3 * o3 + ob
-    # output = sigmoid(output)
-    output = activation(output)
-    
-    error = target - output
-    # derror = error * sigmoid_prime(output)
-    derror = error * activation_prime(output)
-    
-    # ds1 = derror * o1 * sigmoid_prime(s1)
-    ds1 = derror * o1 * activation_prime(s1)
-    # ds2 = derror * o2 * sigmoid_prime(s2)
-    ds2 = derror * o2 * activation_prime(s2)
-    # ds3 = derror * o3 * sigmoid_prime(s3)
-    ds3 = derror * o3 * activation_prime(s3)
-    
-    o1 += alpha * s1 * derror
-    o2 += alpha * s2 * derror
-    o3 += alpha * s3 * derror
-    ob += alpha * derror
+    def learn(self, i1, i2, target, activation=sigmoid, activation_prime=sigmoid_prime, alpha=0.2):
+        s1 = self._w11 * i1 + self._w21 * i2 + self._b1
+        s1 = activation(s1)
+        s2 = self._w12 * i1 + self._w22 * i2 + self._b2
+        s2 = activation(s2)
+        s3 = self._w13 * i1 + self._w23 * i2 + self._b3
+        s3 = activation(s3)
+        
+        output = s1 * self._o1 + s2 * self._o2 + s3 * self._o3 + self._ob
+        output = activation(output)
+        
+        error = target - output
     
-    w11 += alpha * i1 * ds1
-    w21 += alpha * i2 * ds1
-    b1 += alpha * ds1
-    w12 += alpha * i1 * ds2
-    w22 += alpha * i2 * ds2
-    b2 += alpha * ds2
-    w13 += alpha * i1 * ds3
-    w23 += alpha * i2 * ds3
-    b3 += alpha * ds3   
-
-
-def train(epochs=EPOCHS, alpha=ALPHAS):
-    modelo = None
-    for epoch in range(1,epochs+1):
-        indexes = [0,1,2,3]
-        random.shuffle(indexes)
-        for j in indexes:
-            learn(INPUTS[j][0],INPUTS[j][1],OUTPUTS[j][0], activation=sigmoid, activation_prime=sigmoid_prime, alpha=alpha)
+        derror = error * activation_prime(output)
+        ds1 = derror * self._o1 * activation_prime(s1)
+        ds2 = derror * self._o2 * activation_prime(s2)
+        ds3 = derror * self._o3 * activation_prime(s3)
+        
+        self._o1 += alpha * s1 * derror
+        self._o2 += alpha * s2 * derror
+        self._o3 += alpha * s3 * derror
+        self._ob += alpha * derror
         
-        if epoch%WEPOCHS  == 0:
-            cost = 0
-            for j in range(4):
-                o = predict(INPUTS[j][0],INPUTS[j][1], activation=sigmoid)
-                cost += (OUTPUTS[j][0] - o) ** 2
-            cost /= 4
-            print("epoch", epoch, "mean squared error:", cost)
+        self._w11 += alpha * i1 * ds1
+        self._w21 += alpha * i2 * ds1
+        self._b1 += alpha * ds1
+        self._w12 += alpha * i1 * ds2
+        self._w22 += alpha * i2 * ds2
+        self._b2 += alpha * ds2
+        self._w13 += alpha * i1 * ds3
+        self._w23 += alpha * i2 * ds3
+        self._b3 += alpha * ds3   
+
+
+    def train(self, inputs=[], outputs=[], epochs=EPOCHS, alpha=ALPHAS):
+        if len(inputs) > 0 and len(outputs) > 0:
+            for epoch in range(1,epochs+1):
+                indexes = [0,1,2,3]
+                random.shuffle(indexes)
+                for j in indexes:
+                    self.learn(inputs[j][0],inputs[j][1],outputs[j][0], activation=sigmoid, activation_prime=sigmoid_prime, alpha=alpha)
+            
+                # Print cost every 100 epochs for debug
+                if epoch%WEPOCHS  == 0:
+                    cost = 0
+                    for j in range(4):
+                        o = self.predict(inputs[j][0],inputs[j][1], activation=sigmoid)
+                        cost += (outputs[j][0] - o) ** 2
+                    cost /= 4
+                    print("epoch", epoch, "mean squared error:", cost)
+
+    def save_model(self, filename):
+        model = self.getModelJson()
+        with open(filename, 'w') as json_file:
+            json.dump(model, json_file)
+
+    def getModelJson(self):
+        return {
+            "w11": self._w11,
+            "w21": self._w21,
+            "b1": self._b1,
+            "w12": self._w12,
+            "w22": self._w22,
+            "b2": self._b2,
+            "w13": self._w13,
+            "w23": self._w23,
+            "b3": self._b3,
+            "o1": self._o1,
+            "o2": self._o2,
+            "o3": self._o3,
+            "ob": self._ob
+        }
+    
+    def __str__(self):
+        return self.getModelJson()
     
-    modelo = {
-        "w11": w11,
-        "w21": w21,
-        "b1": b1,
-        "w12": w12,
-        "w22": w22,
-        "b2": b2,
-        "w13": w13,
-        "w23": w23,
-        "b3": b3,
-        "o1": o1,
-        "o2": o2,
-        "o3": o3,
-        "ob": ob
-    }
-    return modelo
-
-def save_model(modelo, filename):
-    with open(filename, 'w') as json_file:
-        json.dump(modelo, json_file)
 
 ## Main
 def main():
+    INPUTS = [[0,0],[0,1],[1,0],[1,1]]
+    OUTPUTS = [[0],[1],[1],[0]]
     # Train model
-    modelo = train()    
-    
-    print(modelo)
-    # Save model to file
-    save_model(modelo, "modelo.json")
+    nn = NeuralNetwork()
+    print("Neural Network created")
+    nn.train(inputs=INPUTS, outputs=OUTPUTS, epochs=EPOCHS, alpha=ALPHAS)
+    print("Model trained")
+    print("Printing Model:")
+    print(nn._getModelJson())
+
+    # Save model to files
+    nn.save_model("model.json")
+    print("Model saved to model.json")
 
     for i in range(4):
-        result = predict(INPUTS[i][0],INPUTS[i][1], activation=sigmoid)
+        result = nn.predict(INPUTS[i][0],INPUTS[i][1], activation=sigmoid)
         print("for input", INPUTS[i], "expected", OUTPUTS[i][0], "predicted", f"{result:4.4}", "which is", "correct" if round(result)==OUTPUTS[i][0] else "incorrect")
-        # print("for input", INPUTS[i], "expected", OUTPUTS[i][0], "predicted", result, "which is", "correct" if round(result)==OUTPUTS[i][0] else "incorrect")
-
 
 if __name__ == "__main__":
     main()

utils.py

@@ -0,0 +1,25 @@
+import math
+
+def sigmoid(x):
+    return 1.0 / (1.0 + math.exp(-x))
+
+def sigmoid_prime(x): # x already sigmoided
+    return x * (1 - x)
+
+def relu(x):
+    return max(0,x)
+
+def relu_prime(x):
+    return 1 if x>0 else 0
+
+def tanh(x):
+    return math.tanh(x)
+
+def tanh_prime(x):
+    return 1 - x**2
+
+def softmax(x):
+    return math.exp(x) / (math.exp(x) + 1)
+
+def softmax_prime(x):
+    return x * (1 - x)