Create bot.py

bot.py

@@ -0,0 +1,162 @@
+from abc import ABC, abstractmethod
+import nltk
+import random
+import numpy as np
+import json
+import pickle
+from nltk.stem import WordNetLemmatizer
+from tensorflow.keras.models import Sequential, load_model
+from tensorflow.keras.layers import Dense, Activation, Dropout
+from tensorflow.keras.optimizers import SGD
+
+class ChatbotModel(ABC):
+    @abstractmethod
+    def load_data(self, file_path): pass
+    @abstractmethod
+    def load_model(self, model_path): pass
+    @abstractmethod
+    def clean_up_sentence(self, sentence): pass
+    @abstractmethod
+    def bag_of_words(self, sentence): pass
+    @abstractmethod
+    def predict_class(self, sentence): pass
+    @abstractmethod
+    def get_response(self, intents_list): pass
+    @abstractmethod
+    def chat(self, text): pass
+    @abstractmethod
+    def preprocess_data(self): pass
+    @abstractmethod
+    def create_training_data(self, words, classes, documents): pass
+    @abstractmethod
+    def build_model(self, train_x, train_y): pass
+    @abstractmethod
+    def train_model(self, model, train_x, train_y, epochs, batch_size): pass
+
+class GenAIGlobalImpactElectionsbot(ChatbotModel):
+    def __init__(self, intents_file, model_file, words_file, classes_file):
+        self.intents = self.load_data(intents_file)
+        self.words = pickle.load(open(words_file, 'rb'))
+        self.classes = pickle.load(open(classes_file, 'rb'))
+        self.model = self.load_model(model_file)
+        self.lemmatizer = WordNetLemmatizer()
+
+    def load_data(self, file_path):
+        with open(file_path) as json_file:
+            return json.load(json_file)
+
+    def load_model(self, model_path):
+        return load_model(model_path)
+
+    def clean_up_sentence(self, sentence):
+        sentence_words = nltk.word_tokenize(sentence)
+        sentence_words = [self.lemmatizer.lemmatize(word.lower()) for word in sentence_words]
+        return sentence_words
+
+    def bag_of_words(self, sentence):
+        sentence_words = self.clean_up_sentence(sentence)
+        bag = [0] * len(self.words)
+        for w in sentence_words:
+            for i, word in enumerate(self.words):
+                if word == w:
+                    bag[i] = 1
+        return np.array(bag)
+
+    def predict_class(self, sentence):
+        bow = self.bag_of_words(sentence)
+        res = self.model.predict(np.array([bow]))[0]
+        ERROR_THRESHOLD = 0.25
+        results = [[i, r] for i, r in enumerate(res) if r > ERROR_THRESHOLD]
+
+        results.sort(key=lambda x: x[1], reverse=True)
+        return_list = []
+        for r in results:
+            return_list.append({'intent': self.classes[r[0]], 'probability': str(r[1])})
+        return return_list
+
+    def get_response(self, intents_list):
+        tag = intents_list[0]['intent']
+        list_of_intents = self.intents['intents']
+        for i in list_of_intents:
+            if i['tag'] == tag:
+                result = random.choice(i['responses'])
+                break
+        return result
+
+    def chat(self, text):
+        ints = self.predict_class(text)
+        res = self.get_response(ints)
+        return res
+
+    def preprocess_data(self):
+        words = []
+        classes = []
+        documents = []
+        ignore_words = ['?', '!']
+        for intent in self.intents['intents']:
+            for pattern in intent['patterns']:
+                word_list = nltk.word_tokenize(pattern)
+                words.extend(word_list)
+                documents.append((word_list, intent['tag']))
+                if intent['tag'] not in classes:
+                    classes.append(intent['tag'])
+        words = [self.lemmatizer.lemmatize(word.lower()) for word in words if word not in ignore_words]
+        words = sorted(list(set(words)))
+        classes = sorted(list(set(classes)))
+        pickle.dump(words, open('words.pkl', 'wb'))
+        pickle.dump(classes, open('classes.pkl', 'wb'))
+        return words, classes, documents
+
+    def create_training_data(self, words, classes, documents):
+        training = []
+        output_empty = [0] * len(classes)
+        for doc in documents:
+            bag = []
+            word_patterns = doc[0]
+            word_patterns = [self.lemmatizer.lemmatize(word.lower()) for word in word_patterns]
+            for word in words:
+                bag.append(1) if word in word_patterns else bag.append(0)
+            output_row = list(output_empty)
+            output_row[classes.index(doc[1])] = 1
+            training.append([bag, output_row])
+        training = np.array(training, dtype=object)
+        train_x = list(training[:, 0])
+        train_y = list(training[:, 1])
+        return train_x, train_y
+
+    def build_model(self, train_x, train_y):
+        model = Sequential()
+        model.add(Dense(128, input_shape=(len(train_x[0]),), activation='relu'))
+        model.add(Dropout(0.5))
+        model.add(Dense(64, activation='relu'))
+        model.add(Dropout(0.5))
+        model.add(Dense(len(train_y[0]), activation='softmax'))
+        sgd = SGD(learning_rate=0.01, decay=1e-6, momentum=0.9, nesterov=True)
+        model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])
+        return model
+
+    def train_model(self, model, train_x, train_y, epochs=200, batch_size=5):
+        model.fit(np.array(train_x), np.array(train_y), epochs=epochs, batch_size=batch_size, verbose=1)
+        model.save('Gen-E1_chatbot.h5')
+        return model
+
+# Example usage
+if __name__ == "__main__":
+    # Initialize the GenAIGlobalImpactElectionsbot
+    Gen_E1 = GenAIGlobalImpactElectionsbot('intents.json', 'Gen-E1_chatbot.h5', 'words.pkl', 'classes.pkl')
+
+    # Preprocess data and create training data
+    words, classes, documents = Gen_E1.preprocess_data()
+    train_x, train_y = Gen_E1.create_training_data(words, classes, documents)
+
+    # Build and train the model
+    model = Gen_E1.build_model(train_x, train_y)
+    Gen_E1.train_model(model, train_x, train_y)
+
+    # Chat with the Gen-E1
+    while True:
+        user_input = input("You: ")
+        if user_input.lower() in ['exit', 'quit']:
+            break
+        response = Gen_E1.chat(user_input)
+        print(f"Gen-E1: {response}")