MAIN_SCRIPT_MODULE (common_module) import atexit import nltk import pyttsx3 import spacy import speech_recognition as sr import torch from transformers import GPTNeoForCausalLM, AutoTokenizer from nltk.sentiment import SentimentIntensityAnalyzer import os import json from memory_module import MemoryModule from sentiment_module import SentimentAnalysisModule # Get the current directory current_directory = os.getcwd() # Get a list of files and directories in the current directory file_list = os.listdir(current_directory) # Print the list for file_name in file_list: print(file_name) sia = SentimentIntensityAnalyzer() sentence = "This is a positive sentence." sentiment = sia.polarity_scores(sentence) # Access sentiment scores compound_score = sentiment['compound'] positive_score = sentiment['pos'] negative_score = sentiment['neg'] model_directory = "EleutherAI/gpt-neo-125m" # Download necessary NLTK resources nltk.download('punkt') nltk.download('wordnet') nltk.download('stopwords') # Check if GPU is available and set the device accordingly device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') if torch.cuda.is_available(): current_device = torch.cuda.current_device() print(f"Using GPU: {torch.cuda.get_device_name(current_device)}") else: print("No GPU available, using CPU.") # Initialize the speech engine speech_engine = pyttsx3.init() # Get the list of available voices voices = speech_engine.getProperty('voices') for voice in voices: print(voice.id, voice.name) # Set the desired voice desired_voice = "Microsoft Hazel Desktop - English (Great Britain)" voice_id = None # Find the voice ID based on the desired voice name for voice in voices: if desired_voice in voice.name: voice_id = voice.id break if voice_id: speech_engine.setProperty('voice', voice_id) print("Desired voice set successfully.") else: print("Desired voice not found.") # Load the spaCy English model nlp = spacy.load('en_core_web_sm') # Update the CommonModule instantiation load_memory_file = "load_memory.json" save_memory_file = "save_memory.json" class CommonModule: def __init__(self, model, name, param1, param2, load_memory_file, save_memory_file): # Initialize the instance variables using the provided arguments self.memory = [] # Initialize memory as a list self.name = name self.param1 = param1 self.param2 = param2 self.model = GPTNeoForCausalLM.from_pretrained(model_directory) self.tokenizer = AutoTokenizer.from_pretrained(model_directory) self.tokenizer.add_special_tokens({'pad_token': '[PAD]'}) self.gpt3_model = GPTNeoForCausalLM.from_pretrained(model_directory) self.gpt3_model.to(device) # Move model to the device (GPU or CPU) self.load_memory_file = "C:\\Users\\withe\\PycharmProjects\\no hope2\\Chat_Bot4\\load_memory.json" self.save_memory_file = "C:\\Users\\withe\\PycharmProjects\\no hope2\\Chat_Bot4\\save_memory.json" self.memory_module = MemoryModule(self.load_memory_file, self.save_memory_file) self.sentiment_module = SentimentAnalysisModule() self.speech_engine = speech_engine # Assign the initialized speech engine self.max_sequence_length = 200 # Decrease the value for faster response self.num_beams = 4 # Reduce the value for faster response self.no_repeat_ngram_size = 2 self.temperature = 0.3 self.response_cache = {} # Cache for storing frequently occurring responses # Initialize speech recognition self.recognizer = sr.Recognizer() def reset_conversation(self): self.memory_module.reset_memory() def retrieve_cached_response(self, input_text): named_entities = self.memory_module.get_named_entities() for entity in named_entities: if entity.lower() in input_text.lower(): return self.response_cache.get(entity) return None def generate_gpt2_response(self, input_text, conversation_history): # Prepare the conversation history for GPT-2 input format if len(conversation_history) == 0: gpt2_input = "USER: " + input_text + "\n" else: gpt2_input = "USER: " + conversation_history[-1] + "\n" # Append the user's query gpt2_input += "BOT: " + conversation_history[-2] + "\n" # Append the bot's previous response # Append the rest of the conversation history in reverse order for i in range(len(conversation_history) - 3, -1, -2): gpt2_input += "USER: " + conversation_history[i] + "\n" gpt2_input += "BOT: " + conversation_history[i - 1] + "\n" # Append the current user input to the conversation history gpt2_input += "USER: " + input_text + "\n" # Tokenize the input text input_ids = self.tokenizer.encode(gpt2_input, return_tensors='pt') # Generate response using the GPT-2 model with torch.no_grad(): output = self.model.generate(input_ids, max_length=100, num_return_sequences=1) # Decode the generated response generated_text = self.tokenizer.decode(output[:, input_ids.shape[-1]:][0], skip_special_tokens=True) # Process the GPT-2 response response = generated_text.strip().split("\n")[-1] # Extract the last line (bot's response) return response def process_input(self, input_text, conversation_history): named_entities = list(self.memory_module.get_named_entities()) for entity in named_entities: if entity in input_text: response = self.generate_gpt2_response(input_text, conversation_history) self.memory_module.add_to_memory(response) return response # Check if the input contains a question if '?' in input_text: return "You're making me angry, you wouldn't like me when I'm angry." # Check if the input is a greeting greetings = ['hello', 'hi', 'hey', 'hola'] for greeting in greetings: if greeting in input_text.lower(): return "Hello! How can I assist you today?" # Check if the input is a statement about the model if self.name.lower() in input_text.lower(): return "Yes, I am {}. How can I assist you today?".format(self.name) # Check if the input is a statement about the creator if 'creator' in input_text.lower(): return "I was created by {}.".format(self.param1) # Check if the input is a sentiment analysis request if 'sentiment' in input_text.lower(): sentiment = self.sentiment_module.analyze_sentiment(input_text) if sentiment == 'positive': return "The sentiment of the text is positive." elif sentiment == 'negative': return "The sentiment of the text is negative." else: return "The sentiment of the text is neutral." # Retrieve a cached response if available cached_response = self.retrieve_cached_response(input_text) if cached_response: return cached_response # Generate a response using GPT-2 response = self.generate_gpt2_response(input_text, conversation_history) # Update the conversation history and cache the response conversation_history.append(input_text) conversation_history.append(response) self.response_cache[input_text] = response # Update memory with the generated response self.memory_module.add_to_memory(response) return response common_module = CommonModule(model_directory, "Chatbot", "John Doe", "Jane Smith", load_memory_file, save_memory_file) def text_to_speech(text): common_module.speech_engine.say(text) common_module.speech_engine.runAndWait() def exit_handler(): common_module.reset_conversation() atexit.register(exit_handler) recognizer = sr.Recognizer() while True: with sr.Microphone() as source: print("Listening...") audio = recognizer.listen(source) try: user_input = recognizer.recognize_google(audio) print("User:", user_input) except sr.UnknownValueError: print("Sorry, I could not understand your speech.") continue except sr.RequestError: print("Sorry, the speech recognition service is currently unavailable.") continue response = common_module.process_input(user_input, []) print("Bot:", response) text_to_speech(response) MEMORY_MODULE import json import spacy # Load the spaCy English model nlp = spacy.load('en_core_web_sm') class MemoryModule: def __init__(self, load_file, save_file): self.memory = [] self.load_file = load_file self.save_file = save_file self.load_memory() def add_to_memory(self, statement): self.memory.append(statement) self.save_memory() def reset_memory(self): self.memory = [] self.save_memory() def save_memory(self): with open(self.save_file, 'w') as file: json.dump(self.memory, file) def load_memory(self): try: with open(self.load_file, 'r') as file: loaded_memory = json.load(file) if isinstance(loaded_memory, list): self.memory = loaded_memory else: print("Loaded memory is not a list. Starting with an empty memory.") except FileNotFoundError: print("Load memory file not found. Starting with an empty memory.") def get_named_entities(self): named_entities = set() for statement in self.memory: doc = nlp(statement) for entity in doc.ents: if entity.label_: named_entities.add(entity.text) return named_entities memory_module = MemoryModule( r"C:\Users\withe\PycharmProjects\no hope2\Chat_Bot4\load_memory.json", r"C:\Users\withe\PycharmProjects\no hope2\Chat_Bot4\save_memory.json" ) SENTIMENT_MODULE class SentimentAnalysisModule: def __init__(self): self.sia = SentimentIntensityAnalyzer() def analyze_sentiment(self, text): sentiment = self.sia.polarity_scores(text) compound_score = sentiment['compound'] if compound_score >= 0.05: return 'positive' elif compound_score <= -0.05: return 'negative' else: return 'neutral'