Initial Commit "Some minor Changes and Improvements"

Author: muhammad-fiaz

build/lib/neurolink/Scripts/__init__.py

@@ -1,6 +1,4 @@
-import os
-
-from neurolink.Scripts.__tflearn__ import chat
+from neurolink.Scripts.Engines.__tflearn__ import chat
 
 
 class initialize:

build/lib/neurolink/neurolink.py

@@ -1 +0,0 @@
-from neurolink import initialize as neurolink

neurolink/Scripts/Engines/__init__.py

@@ -1,14 +1,48 @@
+import json
 import numpy as np
 from tensorflow import keras
 from nltk.stem.lancaster import LancasterStemmer
 import nltk
 import os
 import pickle
-from neurolink.include import __load__
-from neurolink.include.__process__ import *
 
 
-# Build and compile the model
+def preprocess_data(data):
+    words = []
+    labels = []
+    docs_x = []
+    docs_y = []
+    for intent in data["intents"]:
+        for pattern in intent["patterns"]:
+            wrds = nltk.word_tokenize(pattern)
+            words.extend(wrds)
+            docs_x.append(wrds)
+            docs_y.append(intent["tag"])
+        if intent["tag"] not in labels:
+            labels.append(intent["tag"])
+    words = [LancasterStemmer().stem(w.lower()) for w in words if w != "?"]
+    words = sorted(list(set(words)))
+    labels = sorted(labels)
+    training = []
+    output = []
+    out_empty = [0 for _ in range(len(labels))]
+    for x, doc in enumerate(docs_x):
+        bag = []
+        wrds = [LancasterStemmer().stem(w) for w in doc]
+        for w in words:
+            if w in wrds:
+                bag.append(1)
+            else:
+                bag.append(0)
+        output_row = out_empty[:]
+        output_row[labels.index(docs_y[x])] = 1
+        training.append(bag)
+        output.append(output_row)
+    training = np.array(training)
+    output = np.array(output)
+    return words, labels, training, output
+
+
 def build_model(input_shape, output_shape):
     model = keras.Sequential([
         keras.layers.Dense(8, input_shape=input_shape, activation='relu'),
@@ -18,12 +52,10 @@ def build_model(input_shape, output_shape):
     return model
 
 
-# Train the model
 def train_model(model, training, output, epochs, verbose=1):
     model.fit(training, output, epochs=epochs, verbose=verbose)
 
 
-# Predict the intent
 def predict_intent(sentence, model, words, labels):
     sentence_words = nltk.word_tokenize(sentence)
     sentence_words = [LancasterStemmer().stem(word.lower()) for word in sentence_words]
@@ -39,11 +71,11 @@ def predict_intent(sentence, model, words, labels):
     return intent
 
 
-# Use the model to predict intents
 def chat(message, confidence_threshold, intents_path, model_path, data_path, should_train_model):
     if should_train_model:
         # Load and preprocess the data
-        data = __load__.load_data(intents_path)
+        with open(intents_path, "r") as file:
+            data = json.load(file)
         words, labels, training, output = preprocess_data(data)
 
         # Build and compile the model
@@ -55,15 +87,15 @@ def chat(message, confidence_threshold, intents_path, model_path, data_path, sho
         epochs = 1000
         train_model(model, training, output, epochs, verbose=0)
 
-        # Save the model
-        model.save(model_path)
+        # Save the model in the native Keras format
+        model.save(model_path + '.keras')
 
         # Save words and labels using pickle
         with open(data_path, 'wb') as file:
             pickle.dump((words, labels), file)
 
     else:
-        model = keras.models.load_model(model_path)
+        model = keras.models.load_model(model_path + '.keras')
         with open(data_path, 'rb') as file:
             words, labels = pickle.load(file)
 
@@ -74,23 +106,36 @@ def chat(message, confidence_threshold, intents_path, model_path, data_path, sho
         return "Sorry, I don't understand. Please try again."
 
 
-class botModel_keras:
+class initialize_keras_model:
     """
-    these are the test case for the chat function
-intents_path = os.path.abspath("intents.json")
-model_path = os.path.abspath("model.tflearn")
-data_path = os.path.abspath("data.pickle")
-
-response = chat("Hi", 0.5, intents_path, model_path, data_path, train_model=False)
+    these are the parameters that are required to initialize the chatbot
+intents_path = os.path.abspath("../../intents.json")
+model_dir = os.path.dirname(os.path.abspath(__file__))
+model_path = os.path.join(model_dir, "model")
+data_path = os.path.join(model_dir, "data.pickle")
+
+initialize = initialize(intents_path, model_path, data_path, should_train_model=True)
+response = initialize.keras("Hi", 0.5)
 print(response)
-"""
-
-    def __init__(self, intents_path, model_path, data_path, train_model):
+    """
+    def __init__(self, intents_path, model_path, data_path, should_train_model):
         self.intents_path = intents_path
         self.model_path = model_path
         self.data_path = data_path
-        self.train_model = train_model
-
-    def chat(self, message, accuracy):
-        response = chat(message, accuracy, self.intents_path, self.model_path, self.data_path, self.train_model)
+        self.should_train_model = should_train_model
+
+    def keras(self, message, confidence_threshold):
+        response = chat(
+            message,
+            confidence_threshold,
+            self.intents_path,
+            self.model_path,
+            self.data_path,
+            self.should_train_model
+        )
         return response
+
+
+
+
+

neurolink/Scripts/__keras__.py neurolink/Scripts/Engines/__keras__.pyneurolink/Scripts/__keras__.py renamed to neurolink/Scripts/Engines/__keras__.py

@@ -1,42 +1,16 @@
+import json
 import os
 import random
-import json
+
 import nltk
 import numpy as np
 import torch
 import torch.nn as nn
-from nltk import LancasterStemmer
-from torch.utils.data import Dataset, DataLoader
 from nltk.stem.porter import PorterStemmer
-
-from neurolink.include import __load__
+from torch.utils.data import DataLoader, Dataset
 
 stemmer = PorterStemmer()
 
-model_path = os.path.abspath("../../intents.json")
-
-intents = __load__.load_data(model_path)
-
-
-def bag_of_words(tokenized_sentence, words):
-    # Stem each word
-    sentence_words = [stem(word) for word in tokenized_sentence]
-    # Initialize bag with 0 for each word
-    bag = np.zeros(len(words), dtype=np.float32)
-    for idx, w in enumerate(words):
-        if w in sentence_words:
-            bag[idx] = 1
-    return bag
-
-
-def tokenize(sentence):
-    return nltk.word_tokenize(sentence)
-
-
-def stem(word):
-    return stemmer.stem(word.lower())
-
-
 class ChatDataset(Dataset):
     def __init__(self, X, y):
         self.n_samples = len(X)
@@ -50,6 +24,16 @@ def __len__(self):
         return self.n_samples
 
 
+def bag_of_words(tokenized_sentence, words):
+    # Stem each word
+    sentence_words = [stem(word) for word in tokenized_sentence]
+    # Initialize bag with 0 for each word
+    bag = np.zeros(len(words), dtype=np.float32)
+    for idx, w in enumerate(words):
+        if w in sentence_words:
+            bag[idx] = 1
+    return bag
+
 class NeuralNet(nn.Module):
     def __init__(self, input_size, hidden_size, num_classes):
         super(NeuralNet, self).__init__()
@@ -69,7 +53,18 @@ def forward(self, x):
 
 
 
-def __preprocess_data__(intents):
+def tokenize(sentence):
+    return nltk.word_tokenize(sentence)
+
+
+def stem(word):
+    return stemmer.stem(word.lower())
+
+
+
+
+
+def preprocess_data(intents):
     all_words = []
     tags = []
     xy = []
@@ -101,18 +96,22 @@ def __preprocess_data__(intents):
     return X_train, y_train, all_words, tags
 
 
-X_train, y_train, all_words, tags = __preprocess_data__(intents)
+def train(intents_path, data_path):
 
-num_epochs = 1000
-batch_size = 8
-learning_rate = 0.001
-input_size = len(X_train[0])
-hidden_size = 8
-output_size = len(tags)
-print(input_size, output_size)
+    model_path = os.path.abspath(intents_path)
 
+    with open(model_path, 'r') as file:
+        intents = json.load(file)
 
-def train():
+    X_train, y_train, all_words, tags = preprocess_data(intents)
+
+    num_epochs = 1000
+    batch_size = 8
+    learning_rate = 0.001
+    input_size = len(X_train[0])
+    hidden_size = 8
+    output_size = len(tags)
+    print(input_size, output_size)
     dataset = ChatDataset(X_train, y_train)
     train_loader = DataLoader(dataset=dataset, batch_size=batch_size, shuffle=True, num_workers=0)
     device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
@@ -144,13 +143,12 @@ def train():
         "all_words": all_words,
         "tags": tags
     }
-    data_path = os.path.abspath("data.pth")
-    FILE = data_path
+    FILE = os.path.abspath(data_path)
     torch.save(data, FILE)
     print(f'Training complete. File saved to {FILE}')
 
 
-def chat(message, threshold, intents, data_path):
+def chat(message, threshold, intents_path, data_path):
     # Load other data
     data = torch.load(data_path)
     input_size = data["input_size"]
@@ -174,29 +172,45 @@ def chat(message, threshold, intents, data_path):
     probs = torch.softmax(output, dim=1)
     prob = probs[0][predicted.item()]
     if prob.item() > threshold:
-        for intent in intents:
+        with open(intents_path, 'r') as file:
+            intents = json.load(file)
+        for intent in intents['intents']:
             if tag == intent["tag"]:
                 return random.choice(intent['responses'])
     else:
         return "I do not understand... Could you please rephrase?"
 
 
-train_model = True
+class Initialize:
+    def __init__(self, intents_path, data_path, train_model):
+        self.intents_path = intents_path
+        self.data_path = data_path
+        self.train_model = train_model
+        self.intents = None
 
-if train_model:
-    train()
+    def train(self):
+        if self.train_model:
+            train(self.intents_path, self.data_path)
 
-intents_path = os.path.abspath("../../intents.json")
-data_path = os.path.abspath("data.pth")
-threshold = 0.75
+    def load_intents(self):
+        with open(self.intents_path, 'r') as file:
+            self.intents = json.load(file)
 
-# Load intents file
-with open(intents_path, 'r') as file:
-    intents = json.load(file)["intents"]
+    def chat(self, message, accuracy):
+        self.train()
+        if not self.intents:
+            self.load_intents()
 
-while True:
-    message = input("User: ")
-    if message.lower() == "quit":
-        break
-    response = chat(message, threshold, intents, data_path)
-    print("Assistant:", response)
+        response = chat(message, accuracy, self.intents_path, self.data_path)
+        return response
+
+"""
+These are some just test case for development.
+"""
+train_model = True
+intents_path = "../../../intents.json"
+data_path = "../../data.pth"
+threshold = 0.75
+initialize_instance = Initialize(intents_path, data_path, train_model)
+response = initialize_instance.chat("Hi", threshold)
+print(response)

neurolink/Scripts/__pytorch__.py neurolink/Scripts/Engines/__pytorch__.pyneurolink/Scripts/__pytorch__.py renamed to neurolink/Scripts/Engines/__pytorch__.py

@@ -122,6 +122,6 @@ def __init__(self, intents_path, model_path, data_path, train_model):
         self.data_path = data_path
         self.train_model = train_model
 
-    def chat(self, message, accuracy):
+    def tfl(self, message, accuracy):
         response = chat(message, accuracy, self.intents_path, self.model_path, self.data_path, self.train_model)
         return response

neurolink/Scripts/__tflearn__.py neurolink/Scripts/Engines/__tflearn__.pyneurolink/Scripts/__tflearn__.py renamed to neurolink/Scripts/Engines/__tflearn__.py

@@ -1,7 +1,5 @@
-import os
-
-from neurolink.Scripts.__tflearn__ import chat
-
+from neurolink.Scripts.Engines.__tflearn__ import initialize as tfl
+from neurolink.Scripts.Engines.__keras__ import initialize_keras_model
 
 class initialize:
     """
@@ -15,14 +13,19 @@ class initialize:
     print(response)
 
     """
+
     def __init__(self, intents_path, model_path, data_path, train_model=True):
         self.intents_path = intents_path
         self.model_path = model_path
         self.data_path = data_path
         self.train_model = train_model
 
-    def chat(self, message, accuracy):
-        response = chat(message, accuracy, self.intents_path, self.model_path, self.data_path, self.train_model)
-        return response
-
-
+    def chat(self, message, accuracy, model):
+        if model == "tfl":
+            response = tfl(self.intents_path, self.model_path, self.data_path, self.train_model)
+            response = response.tfl(message, accuracy)
+            return response
+        elif model == "keras":
+            response = initialize_keras_model(self.intents_path, self.model_path, self.data_path, self.train_model)
+            response = response.keras(message, accuracy)
+            return response