EleutherAI2

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'