import warnings import numpy as np import pandas as pd import os import json import random import gradio as gr import torch from sklearn.preprocessing import OneHotEncoder from transformers import AutoModelForSequenceClassification, AutoTokenizer, AutoModelForCausalLM, pipeline from deap import base, creator, tools, algorithms import nltk from nltk.sentiment import SentimentIntensityAnalyzer from nltk.tokenize import word_tokenize from nltk.tag import pos_tag from nltk.chunk import ne_chunk from textblob import TextBlob import matplotlib.pyplot as plt import seaborn as sns import ssl import spacy from spacy import displacy from collections import Counter import en_core_web_sm from gensim import corpora from gensim.models import LdaModel from gensim.utils import simple_preprocess from neuralcoref import NeuralCoref # NLTK data download try: _create_unverified_https_context = ssl._create_unverified_context except AttributeError: pass else: ssl._create_default_https_context = _create_unverified_https_context nltk.download('words', quiet=True) nltk.download('vader_lexicon', quiet=True) nltk.download('punkt', quiet=True) nltk.download('averaged_perceptron_tagger', quiet=True) nltk.download('maxent_ne_chunker', quiet=True) # Set NLTK data path nltk.data.path.append('/home/user/nltk_data') warnings.filterwarnings('ignore', category=FutureWarning, module='huggingface_hub.file_download') # Load spaCy model nlp = en_core_web_sm.load() # Add NeuralCoref to spaCy pipeline coref = NeuralCoref(nlp.vocab) nlp.add_pipe(coref, name='neuralcoref') # Initialize Example Dataset (For Emotion Prediction) data = { 'context': [ 'I am overjoyed', 'I am deeply saddened', 'I am seething with rage', 'I am exhilarated', 'I am tranquil', 'I am brimming with joy', 'I am grieving profoundly', 'I am at peace', 'I am frustrated beyond measure', 'I am determined to succeed', 'I feel resentment burning within me', 'I am feeling glorious and triumphant', 'I am motivated and inspired', 'I am utterly surprised', 'I am gripped by fear', 'I am trusting and open', 'I feel a sense of disgust', 'I am optimistic and hopeful', 'I am pessimistic and gloomy', 'I feel bored and listless', 'I am envious and jealous' ], 'emotion': [ 'joy', 'sadness', 'anger', 'joy', 'calmness', 'joy', 'grief', 'calmness', 'anger', 'determination', 'resentment', 'glory', 'motivation', 'surprise', 'fear', 'trust', 'disgust', 'optimism', 'pessimism', 'boredom', 'envy' ] } df = pd.DataFrame(data) # Encoding the contexts using One-Hot Encoding (memory-efficient) try: encoder = OneHotEncoder(handle_unknown='ignore', sparse_output=True) except TypeError: encoder = OneHotEncoder(handle_unknown='ignore', sparse=True) contexts_encoded = encoder.fit_transform(df[['context']]) # Encoding emotions emotions_target = pd.Categorical(df['emotion']).codes emotion_classes = pd.Categorical(df['emotion']).categories # Load pre-trained BERT model for emotion prediction emotion_prediction_model = None emotion_prediction_tokenizer = None # Load pre-trained large language model and tokenizer for response generation response_model = None response_tokenizer = None def load_models(): global emotion_prediction_model, emotion_prediction_tokenizer, response_model, response_tokenizer if emotion_prediction_model is None or response_model is None: emotion_prediction_model = AutoModelForSequenceClassification.from_pretrained("bhadresh-savani/distilbert-base-uncased-emotion") emotion_prediction_tokenizer = AutoTokenizer.from_pretrained("bhadresh-savani/distilbert-base-uncased-emotion") response_model_name = "gpt2-xl" response_tokenizer = AutoTokenizer.from_pretrained(response_model_name) response_model = AutoModelForCausalLM.from_pretrained(response_model_name) response_tokenizer.pad_token = response_tokenizer.eos_token # Enhanced Emotional States emotions = { 'joy': {'percentage': 20, 'motivation': 'positive and uplifting', 'intensity': 8}, 'sadness': {'percentage': 15, 'motivation': 'reflective and introspective', 'intensity': 6}, 'anger': {'percentage': 15, 'motivation': 'passionate and driven', 'intensity': 7}, 'fear': {'percentage': 10, 'motivation': 'cautious and protective', 'intensity': 5}, 'love': {'percentage': 15, 'motivation': 'affectionate and caring', 'intensity': 7}, 'surprise': {'percentage': 10, 'motivation': 'curious and intrigued', 'intensity': 6}, 'neutral': {'percentage': 15, 'motivation': 'balanced and composed', 'intensity': 4}, } total_percentage = 100 emotion_history_file = 'emotion_history.json' global conversation_history conversation_history = [] max_history_length = 1000 # Increase the maximum history length def load_historical_data(file_path=emotion_history_file): if os.path.exists(file_path): with open(file_path, 'r') as file: return json.load(file) return [] def save_historical_data(historical_data, file_path=emotion_history_file): with open(file_path, 'w') as file: json.dump(historical_data, file) emotion_history = load_historical_data() def update_emotion(emotion, percentage, intensity): emotions[emotion]['percentage'] += percentage emotions[emotion]['intensity'] = intensity # Normalize percentages total = sum(e['percentage'] for e in emotions.values()) for e in emotions: emotions[e]['percentage'] = (emotions[e]['percentage'] / total) * 100 def normalize_context(context): return context.lower().strip() creator.create("FitnessMulti", base.Fitness, weights=(-1.0, -0.5, -0.2)) creator.create("Individual", list, fitness=creator.FitnessMulti) def evaluate(individual): emotion_values = individual[:len(emotions)] intensities = individual[len(emotions):] total_diff = abs(100 - sum(emotion_values)) intensity_range = max(intensities) - min(intensities) emotion_balance = max(emotion_values) - min(emotion_values) return total_diff, intensity_range, emotion_balance def evolve_emotions(): toolbox = base.Toolbox() toolbox.register("attr_float", random.uniform, 0, 100) toolbox.register("attr_intensity", random.uniform, 0, 10) toolbox.register("individual", tools.initCycle, creator.Individual, toolbox.register("individual", tools.initCycle, creator.Individual, (toolbox.attr_float,) * len(emotions) + (toolbox.attr_intensity,) * len(emotions), n=1) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("mate", tools.cxTwoPoint) toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1, indpb=0.2) toolbox.register("select", tools.selNSGA2) toolbox.register("evaluate", evaluate) population = toolbox.population(n=100) algorithms.eaMuPlusLambda(population, toolbox, mu=50, lambda_=100, cxpb=0.7, mutpb=0.2, ngen=50, stats=None, halloffame=None, verbose=False) best_individual = tools.selBest(population, k=1)[0] emotion_values = best_individual[:len(emotions)] intensities = best_individual[len(emotions):] def predict_emotion(context): load_models() inputs = emotion_prediction_tokenizer(context, return_tensors="pt", truncation=True, max_length=512) with torch.no_grad(): outputs = emotion_prediction_model(**inputs) probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1) predicted_class = torch.argmax(probabilities, dim=-1).item() emotion_labels = ["sadness", "joy", "love", "anger", "fear", "surprise"] return emotion_labels[predicted_class] def sentiment_analysis(text): sia = SentimentIntensityAnalyzer() sentiment_scores = sia.polarity_scores(text) return sentiment_scores def extract_entities(text): doc = nlp(text) # Named Entity Recognition named_entities = [(ent.text, ent.label_) for ent in doc.ents] # Noun Phrases noun_phrases = [chunk.text for chunk in doc.noun_chunks] # Key Phrases (using textrank algorithm) from textacy.extract import keyterms as kt keyterms = kt.textrank(doc, normalize="lemma", topn=5) # Dependency Parsing dependencies = [(token.text, token.dep_, token.head.text) for token in doc] # Part-of-Speech Tagging pos_tags = [(token.text, token.pos_) for token in doc] return { "named_entities": named_entities, "noun_phrases": noun_phrases, "key_phrases": keyterms, "dependencies": dependencies, "pos_tags": pos_tags } def analyze_context(text): doc = nlp(text) # Coreference resolution resolved_text = doc._.coref_resolved # Topic modeling processed_text = simple_preprocess(resolved_text) dictionary = corpora.Dictionary([processed_text]) corpus = [dictionary.doc2bow(processed_text)] lda_model = LdaModel(corpus=corpus, id2word=dictionary, num_topics=3, random_state=42) topics = lda_model.print_topics() return { "resolved_text": resolved_text, "topics": topics } def analyze_text_complexity(text): blob = TextBlob(text) return { 'word_count': len(blob.words), 'sentence_count': len(blob.sentences), 'average_sentence_length': len(blob.words) / len(blob.sentences) if len(blob.sentences) > 0 else 0, 'polarity': blob.sentiment.polarity, 'subjectivity': blob.sentiment.subjectivity } def get_ai_emotion(input_text): predicted_emotion = predict_emotion(input_text) ai_emotion = predicted_emotion ai_emotion_percentage = emotions[predicted_emotion]['percentage'] ai_emotion_intensity = emotions[predicted_emotion]['intensity'] return ai_emotion, ai_emotion_percentage, ai_emotion_intensity def generate_emotion_visualization(ai_emotion, ai_emotion_percentage, ai_emotion_intensity): emotion_visualization_path = 'emotional_state.png' try: plt.figure(figsize=(8, 6)) emotions_df = pd.DataFrame([(e, d['percentage'], d['intensity']) for e, d in emotions.items()], columns=['emotion', 'percentage', 'intensity']) sns.barplot(x='emotion', y='percentage', data=emotions_df) plt.title(f'Current Emotional State: {ai_emotion.capitalize()} ({ai_emotion_percentage:.2f}%)') plt.xlabel('Emotion') plt.ylabel('Percentage') plt.xticks(rotation=90) plt.savefig(emotion_visualization_path) plt.close() except Exception as e: print(f"Error generating emotion visualization: {e}") emotion_visualization_path = None return emotion_visualization_path def generate_response(ai_emotion, input_text, entities, context_analysis): load_models() prompt = f"As an AI assistant, I am currently feeling {ai_emotion}. My response will reflect this emotional state. " prompt += f"The input text contains the following entities: {entities['named_entities']}. " prompt += f"The main topics are: {context_analysis['topics']}. " prompt += f"Considering this context, here's my response to '{input_text}': " inputs = response_tokenizer(prompt, return_tensors="pt", padding=True, truncation=True, max_length=8192) temperature = 0.7 if ai_emotion == 'anger': temperature = 0.9 elif ai_emotion == 'joy': temperature = 0.5 with torch.no_grad(): response_ids = response_model.generate( inputs.input_ids, attention_mask=inputs.attention_mask, max_length=400, num_return_sequences=1, no_repeat_ngram_size=2, do_sample=True, top_k=50, top_p=0.95, temperature=temperature, pad_token_id=response_tokenizer.eos_token_id ) response = response_tokenizer.decode(response_ids[0], skip_special_tokens=True) return response.strip() def interactive_interface(input_text): predicted_emotion = predict_emotion(input_text) sentiment_scores = sentiment_analysis(input_text) text_complexity = analyze_text_complexity(input_text) ai_emotion, ai_emotion_percentage, ai_emotion_intensity = get_ai_emotion(input_text) emotion_visualization = generate_emotion_visualization(ai_emotion, ai_emotion_percentage, ai_emotion_intensity) entities = extract_entities(input_text) context_analysis = analyze_context(input_text) response = generate_response(ai_emotion, input_text, entities, context_analysis) conversation_history.append({'user': input_text, 'response': response}) if len(conversation_history) > max_history_length: conversation_history.pop(0) return { "emotion": predicted_emotion, "sentiment": sentiment_scores, "entities": entities, "context_analysis": context_analysis, "text_complexity": text_complexity, "ai_emotion": ai_emotion, "ai_emotion_percentage": ai_emotion_percentage, "ai_emotion_intensity": ai_emotion_intensity, "emotion_visualization": emotion_visualization, "response": response } # Gradio interface def gradio_interface(input_text): result = interactive_interface(input_text) output = f"Predicted Emotion: {result['emotion']}\n" output += f"Sentiment: {result['sentiment']}\n" output += f"AI Emotion: {result['ai_emotion']} ({result['ai_emotion_percentage']:.2f}%, Intensity: {result['ai_emotion_intensity']:.2f})\n" output += f"Entities: {result['entities']}\n" output += f"Context Analysis: {result['context_analysis']}\n" output += f"Text Complexity: {result['text_complexity']}\n" output += f"AI Response: {result['response']}" return output, result['emotion_visualization'] iface = gr.Interface( fn=gradio_interface, inputs="text", outputs=["text", gr.Image(type="filepath")], title="Enhanced AI Assistant", description="Enter your text to interact with the AI assistant." ) if __name__ == "__main__": iface.launch()