Edit model card

You need to agree to share your contact information to access this model

This repository is publicly accessible, but you have to accept the conditions to access its files and content.

Log in or Sign Up to review the conditions and access this model content.

YAML Metadata Warning: empty or missing yaml metadata in repo card (https://huggingface.co/docs/hub/model-cards#model-card-metadata)

import atexit import pyttsx3 import speech_recognition as sr import torch import nltk from nltk.corpus import stopwords from nltk.stem import WordNetLemmatizer from sklearn.feature_extraction.text import TfidfVectorizer from transformers import GPT2Model, AutoTokenizer, AutoModelForCausalLM, GPTNeoForCausalLM, pipeline from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer import numpy as np import json import os import spacy import sys

import transformers import spacy as nlp import nltk

import spacy import site from pathlib import Path

model_path = spacy.util.get_package_path('en_core_web_sm') print(model_path)

print("transformers version:", transformers.version) print("spacy version:", spacy.version) print("nltk version:", nltk.version)

sys.path.append(r"C:\Users\withe\PycharmProjects\no hope2\Gpt-Neo1")

Download necessary NLTK resources

nltk.download('punkt') nltk.download('stopwords') nltk.download('wordnet') nltk.download('omw-1.4')

Load the API key from the environment file

dotenv_path = './API_KEY.env' (dotenv_path)

Check if GPU is available and set the device accordingly

device = torch.device('cuda:0' if torch.cuda.is_available() else '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

voice_id = "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Speech\Voices\Tokens\TTS_MS_EN-GB_HAZEL_11.0 Microsoft Hazel Desktop - English (Great Britain)" speech_engine.setProperty('voice', voice_id)

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.")

class CommonModule: def init(self, model, name, param1, param2): # Initialize the instance variables using the provided arguments self.model = model self.name = name self.param1 = param1 self.param2 = param2 self.tokenizer = AutoTokenizer.from_pretrained(model) # Load the tokenizer self.tokenizer.add_special_tokens({'pad_token': '[PAD]'}) self.gpt3_model = GPTNeoForCausalLM.from_pretrained('EleutherAI/gpt-neo-1.3B') self.gpt3_model.to(device) # Move model to the device (GPU or CPU) self.memory_module = MemoryModule() self.sentiment_module = SentimentAnalysisModule() self.speech_engine = speech_engine # Assign the initialized speech engine

    self.max_sequence_length = 10  # 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



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_gpt3_response(self, input_text, conversation_history, temperature=0.3):
    prompt = '\n'.join(conversation_history) + '\n' + input_text + '\n'

    generator = pipeline('text-generation', model='EleutherAI/gpt-neo-1.3B')
    output = generator(
        prompt,
        do_sample=True,
        min_length=10,
        max_length=300,
        num_return_sequences=1,
        temperature=0.3
    )

    if output:
        generated_response = output[0]['generated_text'].strip()
        return generated_response

    return ""

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 = "Nice to meet you again, {}!".format(entity)
            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 contains a keyword for memory search
    if 'search' in input_text.lower():
        keyword = input_text.lower().split('search ')[-1]
        matches = self.memory_module.search_memory(keyword)
        if matches:
            return "I found some related information in the memory:\n" + '\n'.join(matches)
        else:
            return "Sorry, I couldn't find any relevant information in the memory."

    # Retrieve the cached response
    response = self.retrieve_cached_response(input_text)

    if response is None:
        response = self.generate_gpt3_response(input_text, conversation_history)
        self.cache_response(input_text, response)

    named_entities = self.memory_module.get_named_entities()
    if named_entities and any(entity in input_text for entity in named_entities):
        response = "Nice to meet you, {}! I'm still {}".format(named_entities[0], self.name)
        self.memory_module.add_to_memory(response)
        return response

    self.memory_module.add_to_memory(response)
    return response

def cache_response(self, input_text, response):
    self.response_cache[input_text] = response

def speak(self, text, conversation_history=None):
    if conversation_history is None:
        conversation_history = []
    conversation_history.append(text)
    full_text = "\n".join(conversation_history)
    print(text)
    self.speech_engine.say(text)
    self.speech_engine.runAndWait()

def listen(self):
    recognizer = sr.Recognizer()

    with sr.Microphone() as source:
        print("Listening...")
        audio = recognizer.listen(source)

    try:
        user_input = recognizer.recognize_google(audio)
        print("You said:", user_input)
        return user_input
    except sr.UnknownValueError:
        print("Sorry, I could not understand your speech.")
    except sr.RequestError as e:
        print("Sorry, an error occurred while processing your request. Please try again.")

    return ""

def converse(self):
    self.reset_conversation()
    self.speak("Hey, what's up bro? I'm {}".format(self.name))

    conversation_history = []

    while True:
        user_input = self.listen()

        if user_input:
            response = self.process_input(user_input, conversation_history)
            self.speak(response, conversation_history)

            # Check if the user input contains a named entity (name)
            named_entities = self.memory_module.get_named_entities()
            if named_entities and any(entity in user_input for entity in named_entities):
                self.speak("Nice to meet you, {}! I'm still {}".format(named_entities[0], self.name),
                           conversation_history)

            conversation_history.append(user_input)

        # Check if the conversation is over (you can define your own condition here)
        if user_input == "bye":
            self.save_memory('C:\\Users\\withe\PycharmProjects\\no hope\\Chat_Bot_Main\\save_memory.json')
            break

def save_memory(self, file_path):
    data = {
        'memory': self.memory_module.memory,
        'named_entities': list(self.memory_module.named_entities)  # Convert set to list
    }
    with open(file_path, 'w') as file:
        json.dump(data, file)

def load_memory_data(self, memory_data):
    self.memory_module.memory = memory_data['memory']
    self.memory_module.named_entities = set(memory_data['named_entities'])

class MemoryModule: def init(self): self.memory = [] self.vectorizer = TfidfVectorizer(stop_words=stopwords.words('english')) self.lemmatizer = WordNetLemmatizer() self.tokenizer = nltk.tokenize.word_tokenize self.named_entities = set() # Set to store named entities like names

def get_named_entities(self):
    return self.named_entities

def preprocess_text(self, text):
    tokens = self.tokenizer(text.lower())
    tokens = [self.lemmatizer.lemmatize(token) for token in tokens if token.isalnum()]
    preprocessed_text = ' '.join(tokens)
    return preprocessed_text

def add_to_memory(self, text):
    preprocessed_text = self.preprocess_text(text)
    self.memory.append(preprocessed_text)

    # Update named entities if any
    named_entity = self.extract_named_entity(text)
    if named_entity:
        self.named_entities.add(named_entity)

def extract_named_entity(self, text):
    doc = nlp(text)
    for entity in doc.ents:
        if entity.label_ in ['PERSON', 'ORG', 'GPE']:
            return entity.text
    return None

def search_memory(self, keyword):
    preprocessed_keyword = self.preprocess_text(keyword)
    vectorized_memory = self.vectorizer.transform(self.memory)
    vectorized_keyword = self.vectorizer.transform([preprocessed_keyword])
    similarity_scores = np.dot(vectorized_memory, vectorized_keyword.T).toarray().flatten()
    sorted_indices = np.argsort(similarity_scores)[::-1]
    matches = [self.memory[i] for i in sorted_indices if similarity_scores[i] > 0.5]
    return matches

def reset_memory(self):
    self.memory = []
    self.named_entities = set()

class SentimentAnalysisModule: def init(self): self.analyzer = SentimentIntensityAnalyzer()

def analyze_sentiment(self, text):
    sentiment_scores = self.analyzer.polarity_scores(text)
    return sentiment_scores

def get_sentiment_label(self, sentiment_scores):
    compound_score = sentiment_scores['compound']
    if compound_score >= 0.05:
        return 'positive'
    elif compound_score <= -0.05:
        return 'negative'
    else:
        return 'neutral'

Define an exit handler function

def exit_handler(common_module): memory_data = { 'memory': common_module.memory_module.memory, 'named_entities': list(common_module.memory_module.named_entities) } common_module.save_memory('C:\Users\withe\PycharmProjects\no hope2\Chat_Bot1\save_memory.json') print("Memory data saved successfully.")

return memory_data

Define a method to check if the load_memory.json file exists

def check_memory_file(file_path): return os.path.isfile(file_path)

Modify the main section of the code to load memory data if the file exists

if name == "main": model = 'gpt2' name = "Chat bot1" param1 = 'value1' param2 = 'value2' common_module = CommonModule(model, name, param1, param2)

memory_file_path = 'C:\\Users\\withe\\PycharmProjects\\no hope2\\Chat_Bot1\\load_memory1.json'
if check_memory_file(memory_file_path):
    with open(memory_file_path, 'r') as file:
        memory_data = json.load(file)
    common_module.load_memory_data(memory_data)

# Register the exit handler
atexit.register(exit_handler, common_module)

common_module.converse()
common_module.save_memory(memory_file_path)
Downloads last month
0
Inference Examples
This model does not have enough activity to be deployed to Inference API (serverless) yet. Increase its social visibility and check back later, or deploy to Inference Endpoints (dedicated) instead.