Update README

Author: Cipher

Janex.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Janex
-Version: 0.0.72
+Version: 0.0.79
 Home-page: https://github.com/Cipher58/Janex-Python
 Download-URL: https://github.com/Cipher58/Janex-Python.git
 Author: Cipher58

Janex.egg-info/SOURCES.txt

@@ -3,11 +3,12 @@ README.md
 setup.py
 Janex/__init__.py
 Janex/chat.py
+Janex/intentclassifier.py
 Janex/main.py
+Janex/vectortoolkit.py
+Janex/word_manipulation.py
 Janex.egg-info/PKG-INFO
 Janex.egg-info/SOURCES.txt
 Janex.egg-info/dependency_links.txt
 Janex.egg-info/requires.txt
-Janex.egg-info/top_level.txt
-Janex/JanexSub/JanexSub.py
-Janex/JanexSub/__init__.py
+Janex.egg-info/top_level.txt

Janex/.DS_Store

@@ -1,15 +1,18 @@
-from main import *
+from intentclassifier import *
+import random
 
-intents_file_path = "./intents.json"
-thesaurus_file_path = "./thesaurus.json"
+Classifier = IntentClassifier()
 
-matcher = IntentMatcher(intents_file_path, thesaurus_file_path)
+Classifier.set_intentsfp("intents.json")
+Classifier.set_vectorsfp("vectors.json")
+Classifier.set_dimensions(300)
 
-input_string = input("You: ")
+Classifier.train_vectors()
 
-intent_class, percentage = matcher.pattern_compare(input_string)
-response = matcher.response_compare(input_string, intent_class)
+Input = input("You: ")
 
-response = matcher.ResponseGenerator(response)
+classification = Classifier.classify(Input)
+
+response = random.choice(classification["responses"])
 
 print(response)

Janex/JanexSub/.DS_Store

@@ -0,0 +1,108 @@
+import json
+from Janex.vectortoolkit import *
+from Janex.word_manipulation import *
+
+class IntentClassifier:
+    def __init__(self):
+        self.intents_file_path = None
+        self.thesaurus_file_path = None
+        self.vectors_file_path = None
+
+    def set_vectorsfp(self, vectors_file_path):
+        self.vectors_file_path = vectors_file_path
+        print(f"Janex: Pre-trained vector file path set to {vectors_file_path}")
+
+    def set_intentsfp(self, intents_file_path):
+        self.intents_file_path = intents_file_path
+
+    def set_dimensions(self, dimensions):
+        self.dimensions = dimensions
+
+    def load_intents(self):
+        with open(self.intents_file_path, "r") as json_file:
+            data = json.load(json_file)
+            return data
+
+    def load_vectors(self):
+        with open(self.vectors_file_path, "r") as json_file:
+            data = json.load(json_file)
+            return data
+
+    def train_vectors(self):
+        vectors = {}
+
+        intents = self.load_intents()
+
+        for intent_class in intents["intents"]:
+            for pattern in intent_class["patterns"]:
+                if pattern is not None:
+                    pattern_tokens = tokenize(pattern)
+                    for token in pattern_tokens:
+                        token_vectors = string_vectorize(token)
+                        token_vectors = reshape_array_dimensions(token_vectors, self.dimensions)
+                        token_vectors = token_vectors.tolist()
+                        vectors[token] = token_vectors
+            for response in intent_class["responses"]:
+                if response is not None:
+                    response_tokens = tokenize(response)
+                    for token in response_tokens:
+                        token_vectors = string_vectorize(token)
+                        token_vectors = reshape_array_dimensions(token_vectors, self.dimensions)
+                        vectors[token] = token_vectors.tolist()
+
+        with open(self.vectors_file_path, "w") as vectors_file:
+            json.dump(vectors, vectors_file)
+
+    def classify(self, input_string):
+        predefined_vectors = self.load_vectors()
+        intents = self.load_intents()
+
+        input_tokens = tokenize(input_string)
+        vectors_to_classify = []
+        highest_similarity = 0
+
+        for token in input_tokens:
+            if token in predefined_vectors:
+                token_vectors = predefined_vectors[token]
+            else:
+                token_vectors = string_vectorize(token)
+
+            token_vectors = reshape_array_dimensions(token_vectors, self.dimensions)
+            vectors_to_classify.append(token_vectors)
+
+        for intent_class in intents["intents"]:
+            intent_vectors_to_classify = []
+            for pattern in intent_class["patterns"]:
+                pattern_tokens = tokenize(pattern)
+                for token in pattern_tokens:
+                    if token in predefined_vectors:
+                        pattern_token_vectors = predefined_vectors[token]
+                        intent_vectors_to_classify.append(pattern_token_vectors)
+
+            vectors_to_classify = reshape_array_dimensions(vectors_to_classify, self.dimensions)
+            intent_vectors_to_classify = reshape_array_dimensions(intent_vectors_to_classify, self.dimensions)
+
+            similarity = calculate_cosine_similarity(vectors_to_classify, intent_vectors_to_classify)
+
+            if similarity > highest_similarity:
+                highest_similarity = similarity
+                most_similar_class = intent_class
+
+        if most_similar_class:
+            return most_similar_class
+
+if __name__ == "__main__":
+    Classifer = IntentClassifier()
+
+    Classifier.set_intentsfp("intents.json")
+    Classifier.set_vectorsfp("vectors.json")
+
+    Classifier.train_vectors()
+
+    Input = input("You: ")
+
+    classification = Classifier.classify(Input)
+
+    Response = random.choice(classification["responses"])
+
+    print(Response)