Upload 17 files

BP_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:85c4ca1f3bff7067955a82ec449853bb472478d67912175cbf7b1e53314800fa
+size 4316

BackPropagation/BackPropagation.py

@@ -0,0 +1,53 @@
+import numpy as np
+from tqdm import tqdm
+
+
+class BackPropogation:
+    def __init__(self,learning_rate=0.01, epochs=100,activation_function='step'):
+        self.bias = 0
+        self.learning_rate = learning_rate
+        self.max_epochs = epochs
+        self.activation_function = activation_function
+
+
+    def activate(self, x):
+        if self.activation_function == 'step':
+            return 1 if x >= 0 else 0
+        elif self.activation_function == 'sigmoid':
+            return 1 if (1 / (1 + np.exp(-x)))>=0.5 else 0
+        elif self.activation_function == 'relu':
+            return 1 if max(0,x)>=0.5 else 0
+
+    def fit(self, X, y):
+        error_sum=0
+        n_features = X.shape[1]
+        self.weights = np.zeros((n_features))
+        for epoch in tqdm(range(self.max_epochs)):
+            for i in range(len(X)):
+                inputs = X[i]
+                target = y[i]
+                weighted_sum = np.dot(inputs, self.weights) + self.bias
+                prediction = self.activate(weighted_sum)
+                
+                # Calculating loss and updating weights.
+                error = target - prediction
+                self.weights += self.learning_rate * error * inputs
+                self.bias += self.learning_rate * error
+                
+            print(f"Updated Weights after epoch {epoch} with {self.weights}")
+        print("Training Completed")
+
+    def predict(self, X):
+        predictions = []
+        for i in range(len(X)):
+            inputs = X[i]
+            weighted_sum = np.dot(inputs, self.weights) + self.bias
+            prediction = self.activate(weighted_sum)
+            predictions.append(prediction)
+        return predictions
+
+
+    
+    
+    
+ 

BackPropagation/__init__.py

@@ -0,0 +1,53 @@
+import numpy as np
+from tqdm import tqdm
+
+
+class BackPropogation:
+    def __init__(self,learning_rate=0.01, epochs=100,activation_function='step'):
+        self.bias = 0
+        self.learning_rate = learning_rate
+        self.max_epochs = epochs
+        self.activation_function = activation_function
+
+
+    def activate(self, x):
+        if self.activation_function == 'step':
+            return 1 if x >= 0 else 0
+        elif self.activation_function == 'sigmoid':
+            return 1 if (1 / (1 + np.exp(-x)))>=0.5 else 0
+        elif self.activation_function == 'relu':
+            return 1 if max(0,x)>=0.5 else 0
+
+    def fit(self, X, y):
+        error_sum=0
+        n_features = X.shape[1]
+        self.weights = np.zeros((n_features))
+        for epoch in tqdm(range(self.max_epochs)):
+            for i in range(len(X)):
+                inputs = X[i]
+                target = y[i]
+                weighted_sum = np.dot(inputs, self.weights) + self.bias
+                prediction = self.activate(weighted_sum)
+                
+                # Calculating loss and updating weights.
+                error = target - prediction
+                self.weights += self.learning_rate * error * inputs
+                self.bias += self.learning_rate * error
+                
+            print(f"Updated Weights after epoch {epoch} with {self.weights}")
+        print("Training Completed")
+
+    def predict(self, X):
+        predictions = []
+        for i in range(len(X)):
+            inputs = X[i]
+            weighted_sum = np.dot(inputs, self.weights) + self.bias
+            prediction = self.activate(weighted_sum)
+            predictions.append(prediction)
+        return predictions
+
+
+    
+    
+    
+ 

BackPropagation/imdb_backpropagation.py

@@ -0,0 +1,26 @@
+from tensorflow.keras.datasets import imdb
+from BackPropagation import BackPropogation
+from tensorflow.keras.preprocessing.sequence import pad_sequences
+from sklearn.metrics import accuracy_score
+import pickle
+
+top_words = 5000
+(X_train, y_train), (X_test,y_test) = imdb.load_data(num_words=top_words)
+
+max_review_length = 500
+
+X_train = pad_sequences(X_train, maxlen=max_review_length)
+X_test = pad_sequences(X_test, maxlen=max_review_length)
+
+backprop = BackPropogation(epochs=100,learning_rate=0.01,activation_function='sigmoid')
+backprop.fit(X_train, y_train)
+pred = backprop.predict(X_test)
+print(f"Accuracy : {accuracy_score(pred, y_test)}")
+
+# Save the model using pickle
+with open('BP_model.pkl', 'wb') as file:
+    pickle.dump(backprop, file)
+
+# Load the model back using pickle
+with open('BP_model.pkl', 'rb') as file:
+    model = pickle.load(file)

DNN/dnn_main.py

@@ -0,0 +1,39 @@
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Dense, Embedding, Flatten
+from tensorflow.keras.datasets import imdb
+from tensorflow.keras.preprocessing.sequence import pad_sequences
+
+
+top_words = 5000
+(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words)
+
+max_review_length = 500
+X_train = pad_sequences(X_train, maxlen=max_review_length)
+X_test = pad_sequences(X_test, maxlen=max_review_length)
+
+# Modelling a sample DNN
+model = Sequential()
+model.add(Embedding(input_dim=top_words, output_dim=24, input_length=max_review_length))
+model.add(Flatten())
+model.add(Dense(64, activation='relu'))
+model.add(Dense(32, activation='relu'))
+model.add(Dense(16, activation='relu'))
+model.add(Dense(1, activation='sigmoid'))
+
+# opt=Adam(learning_rate=0.001)
+model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
+model.summary()
+
+print("Training Started.")
+history = model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=20)
+
+loss, acc = model.evaluate(X_test, y_test)
+print("Training Finished.")
+
+print(f'Test Accuracy: {round(acc * 100)}')
+
+model.save(r'C:\Users\HP\Desktop\Devika_streamlit\DNN_model.h5')
+
+
+
+

DNN_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1dd59e62b447b930b18093e224929984a5cb258f34996c25ac39dd0a10cdeb1f
+size 10735120

LSTM/simplelstm.py

@@ -0,0 +1,34 @@
+# LSTM for sequence classification in the IMDB dataset
+import tensorflow as tf
+from tensorflow.keras.datasets import imdb
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Dense
+from tensorflow.keras.layers import LSTM
+from tensorflow.keras.layers import Embedding
+from tensorflow.keras.preprocessing import sequence
+
+
+# fix random seed for reproducibility
+tf.random.set_seed(7)
+# load the dataset but only keep the top n words, zero the rest
+top_words = 5000
+(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words)
+# truncate and pad input sequences
+max_review_length = 500
+X_train = sequence.pad_sequences(X_train, maxlen=max_review_length)
+X_test = sequence.pad_sequences(X_test, maxlen=max_review_length)
+# create the model
+embedding_vecor_length = 32
+model = Sequential()
+model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length))
+model.add(LSTM(200))
+model.add(Dense(1, activation='sigmoid'))
+model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+print(model.summary())
+model.fit(X_train, y_train, epochs=1, batch_size=64)
+# Final evaluation of the model
+scores = model.evaluate(X_test, y_test, verbose=0)
+print("Accuracy: %.2f%%" % (scores[1]*100))
+
+model.save(r'C:\Users\HP\Desktop\Devika_streamlit\LSTM_model.h5')
+

LSTM_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:177b9e18bbaf02ab907356929bab3a307040fe041955b50c04870d62a9863e2d
+size 4194296

PP_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:84bf4ef3840f8dbc7f2d8d9a7efa66fdbdda5a777c3a5d5f0d931e98e76e6e98
+size 2264

Perceptron/Perceptron.py

@@ -0,0 +1,46 @@
+import numpy as np
+from tqdm import tqdm
+
+
+class Perceptron:
+    
+    def __init__(self,learning_rate=0.01, epochs=100,activation_function='step'):
+        self.bias = 0
+        self.learning_rate = learning_rate
+        self.max_epochs = epochs
+        self.activation_function = activation_function
+
+
+    def activate(self, x):
+        if self.activation_function == 'step':
+            return 1 if x >= 0 else 0
+        elif self.activation_function == 'sigmoid':
+            return 1 if (1 / (1 + np.exp(-x)))>=0.5 else 0
+        elif self.activation_function == 'relu':
+            return 1 if max(0,x)>=0.5 else 0
+
+    def fit(self, X, y):
+        n_features = X.shape[1]
+        self.weights = np.random.randint(n_features, size=(n_features))
+        for epoch in tqdm(range(self.max_epochs)):
+            for i in range(len(X)):
+                inputs = X[i]
+                target = y[i]
+                weighted_sum = np.dot(inputs, self.weights) + self.bias
+                prediction = self.activate(weighted_sum)
+        print("Training Completed")
+
+    def predict(self, X):
+        predictions = []
+        for i in range(len(X)):
+            inputs = X[i]
+            weighted_sum = np.dot(inputs, self.weights) + self.bias
+            prediction = self.activate(weighted_sum)
+            predictions.append(prediction)
+        return predictions
+
+
+    
+    
+    
+ 

Perceptron/__init__.py

@@ -0,0 +1,46 @@
+import numpy as np
+from tqdm import tqdm
+
+
+class Perceptron:
+    
+    def __init__(self,learning_rate=0.01, epochs=100,activation_function='step'):
+        self.bias = 0
+        self.learning_rate = learning_rate
+        self.max_epochs = epochs
+        self.activation_function = activation_function
+
+
+    def activate(self, x):
+        if self.activation_function == 'step':
+            return 1 if x >= 0 else 0
+        elif self.activation_function == 'sigmoid':
+            return 1 if (1 / (1 + np.exp(-x)))>=0.5 else 0
+        elif self.activation_function == 'relu':
+            return 1 if max(0,x)>=0.5 else 0
+
+    def fit(self, X, y):
+        n_features = X.shape[1]
+        self.weights = np.random.randint(n_features, size=(n_features))
+        for epoch in tqdm(range(self.max_epochs)):
+            for i in range(len(X)):
+                inputs = X[i]
+                target = y[i]
+                weighted_sum = np.dot(inputs, self.weights) + self.bias
+                prediction = self.activate(weighted_sum)
+        print("Training Completed")
+
+    def predict(self, X):
+        predictions = []
+        for i in range(len(X)):
+            inputs = X[i]
+            weighted_sum = np.dot(inputs, self.weights) + self.bias
+            prediction = self.activate(weighted_sum)
+            predictions.append(prediction)
+        return predictions
+
+
+    
+    
+    
+ 

Perceptron/imdb_perceptron.py

@@ -0,0 +1,27 @@
+from tensorflow.keras.datasets import imdb
+from Perceptron import  Perceptron
+from tensorflow.keras.preprocessing.sequence import pad_sequences
+from sklearn.metrics import accuracy_score
+import pickle
+
+top_words = 5000
+(X_train, y_train), (X_test,y_test) = imdb.load_data(num_words=top_words)
+
+max_review_length = 500
+X_train = pad_sequences(X_train, maxlen=max_review_length)
+X_test = pad_sequences(X_test, maxlen=max_review_length)
+
+percep = Perceptron(epochs=100)
+
+percep.fit(X_train, y_train)
+pred = percep.predict(X_test)
+
+print(f"Accuracy : {accuracy_score(pred, y_test)}")
+
+# Save the model using pickle
+with open('PP_model.pkl', 'wb') as file:
+    pickle.dump(percep, file)
+
+# Load the model back using pickle
+with open('PP_model.pkl', 'rb') as file:
+    model= pickle.load(file)

RNN/imdb_rnn.py

@@ -0,0 +1,63 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.model_selection import train_test_split
+import tensorflow as tf
+from numpy import argmax
+from tensorflow.keras import Sequential
+from tensorflow.keras.layers import Dense
+from tensorflow.keras.optimizers import RMSprop, Adam
+from tensorflow.keras.datasets import imdb
+from tensorflow.keras.preprocessing.sequence import pad_sequences
+from sklearn.metrics import accuracy_score
+
+
+top_words = 5000
+(X_train, y_train), (X_test,y_test) = imdb.load_data(num_words=top_words)
+
+max_review_length = 500
+X_train = pad_sequences(X_train, maxlen=max_review_length)
+X_test = pad_sequences(X_test, maxlen=max_review_length)
+
+model=tf.keras.models.Sequential([
+   tf.keras.layers.Embedding(input_dim=top_words,output_dim= 24, input_length=max_review_length),
+   tf.keras.layers.SimpleRNN(24, return_sequences=False),
+   tf.keras.layers.Dense(64, activation='relu'),
+   tf.keras.layers.Dense(32, activation='relu'),
+   tf.keras.layers.Dense(1, activation='sigmoid')
+])
+
+# compile the model
+model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
+
+print("----------------------  -------------------------\n")
+
+# summarize the model
+print(model.summary())
+
+print("----------------------  -------------------------\n")
+
+early_stop = tf.keras.callbacks.EarlyStopping(monitor='accuracy', mode='min', patience=10)
+
+print("----------------------  Training -------------------------\n")
+
+# fit the model
+model.fit(x=X_train,
+         y=y_train,
+         epochs=10,
+         validation_data=(X_test, y_test),
+         callbacks=[early_stop]
+         )
+print("----------------------  -------------------------\n")
+
+
+def acc_report(y_true, y_pred):
+   acc_sc = accuracy_score(y_true, y_pred)
+   print(f"Accuracy : {str(round(acc_sc,2)*100)}")
+   return acc_sc
+
+
+preds = (model.predict(X_test) > 0.5).astype("int32")
+print(acc_report(y_test, preds))
+
+model.save(r'C:\Users\HP\Desktop\Devika_streamlit\RNN_model.h5')

RNN_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4da4a9cf95636729817b5c93922bab236954038ac366f5260c02b01a8364ef4c
+size 1548440