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 warnings.filterwarnings('ignore', category=FutureWarning, module='huggingface_hub.file_download') # Download necessary NLTK data 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) nltk.download('words', quiet=True) # 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 = AutoModelForSequenceClassification.from_pretrained("bhadresh-savani/distilbert-base-uncased-emotion") emotion_prediction_tokenizer = AutoTokenizer.from_pretrained("bhadresh-savani/distilbert-base-uncased-emotion") # Load pre-trained large language model and tokenizer for response generation with increased context window response_model_name = "gpt2-xl" response_tokenizer = AutoTokenizer.from_pretrained(response_model_name) response_model = AutoModelForCausalLM.from_pretrained(response_model_name) # Set the pad token response_tokenizer.pad_token = response_tokenizer.eos_token # Enhanced Emotional States emotions = { 'joy': {'percentage': 10, 'motivation': 'positive and uplifting', 'intensity': 0}, 'sadness': {'percentage': 10, 'motivation': 'reflective and introspective', 'intensity': 0}, 'anger': {'percentage': 10, 'motivation': 'passionate and driven', 'intensity': 0}, 'fear': {'percentage': 10, 'motivation': 'cautious and protective', 'intensity': 0}, 'love': {'percentage': 10, 'motivation': 'affectionate and caring', 'intensity': 0}, 'surprise': {'percentage': 10, 'motivation': 'curious and intrigued', 'intensity': 0}, 'neutral': {'percentage': 40, 'motivation': 'balanced and composed', 'intensity': 0}, } 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 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.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):] for i, (emotion, data) in enumerate(emotions.items()): data['percentage'] = emotion_values[i] data['intensity'] = intensities[i] # Normalize percentages total = sum(e['percentage'] for e in emotions.values()) for e in emotions: emotions[e]['percentage'] = (emotions[e]['percentage'] / total) * 100 def predict_emotion(context): 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): chunked = ne_chunk(pos_tag(word_tokenize(text))) entities = [] for chunk in chunked: if hasattr(chunk, 'label'): entities.append(((' '.join(c[0] for c in chunk)), chunk.label())) return entities 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): # Generate an emotion visualization based on the AI's emotional state emotion_visualization_path = 'emotional_state.png' try: # Generate and save the emotion visualization 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(input_text, ai_emotion, conversation_history): # Prepare a prompt based on the current emotion and input prompt = f"As an AI assistant, I am currently feeling {ai_emotion}. My response will reflect this emotional state. Human: {input_text}\nAI: " # Add conversation history to the prompt for entry in conversation_history[-100:]: # Use last 100 entries for context prompt = f"Human: {entry['user']}\nAI: {entry['response']}\n" + prompt inputs = response_tokenizer(prompt, return_tensors="pt", padding=True, truncation=True, max_length=8192) # Adjust generation parameters based on emotion temperature = 0.7 if ai_emotion == 'anger': temperature = 0.9 # More randomness for angry responses elif ai_emotion == 'joy': temperature = 0.5 # More focused responses for joyful state with torch.no_grad(): response_ids = response_model.generate( inputs.input_ids, attention_mask=inputs.attention_mask, max_length=8192, 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) # Extract only the AI's response return response.strip() def interactive_interface(input_text): # Perform your processing logic here predicted_emotion = predict_emotion(input_text) sentiment_scores = sentiment_analysis(input_text) entities = extract_entities(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) response = generate_response(input_text, ai_emotion, conversation_history) # Update conversation history conversation_history.append({'user': input_text, 'response': response}) if len(conversation_history) > max_history_length: conversation_history.pop(0) # Return the expected outputs in the correct order return ( gr.Textbox(value=predicted_emotion, label="Predicted Emotion"), gr.Textbox(value=str(sentiment_scores), label="Sentiment Scores"), gr.Textbox(value=str(entities), label="Extracted Entities"), gr.Textbox(value=str(text_complexity), label="Text Complexity"), gr.Textbox(value=ai_emotion, label="AI Emotion"), gr.Textbox(value=f"{ai_emotion_percentage:.2f}%", label="AI Emotion Percentage"), gr.Textbox(value=f"{ai_emotion_intensity:.2f}", label="AI Emotion Intensity"), gr.Image(value=emotion_visualization, label="Emotion Visualization"), gr.Textbox(value=f"As an AI assistant, I am currently feeling {ai_emotion}. My response will reflect this emotional state.\n\n{response}", label="AI Response") ) # 443 additional features additional_features = {} for i in range(443): additional_features[f'feature_{i+1}'] = 0 def feature_transformations(): global additional_features for feature in additional_features: additional_features[feature] += random.uniform(-1, 1) def visualize_emotions(): emotions_df = pd.DataFrame([(e, d['percentage'], d['intensity']) for e, d in emotions.items()], columns=['emotion', 'percentage', 'intensity']) plt.figure(figsize=(12, 6)) sns.barplot(x='emotion', y='percentage', data=emotions_df) plt.title('Emotion Percentages') plt.xlabel('Emotion') plt.ylabel('Percentage') plt.xticks(rotation=90) plt.savefig('emotion_percentages.png') plt.figure(figsize=(12, 6)) sns.barplot(x='emotion', y='intensity', data=emotions_df) plt.title('Emotion Intensities') plt.xlabel('Emotion') plt.ylabel('Intensity') plt.xticks(rotation=90) plt.savefig('emotion_intensities.png') return 'emotion_percentages.png', 'emotion_intensities.png' # Create the Gradio interface iface = gr.Interface( fn=interactive_interface, inputs=gr.Textbox(label="Input Text"), outputs=[ gr.Textbox(label="Predicted Emotion"), gr.Textbox(label="Sentiment Scores"), gr.Textbox(label="Extracted Entities"), gr.Textbox(label="Text Complexity"), gr.Textbox(label="AI Emotion"), gr.Textbox(label="AI Emotion Percentage"), gr.Textbox(label="AI Emotion Intensity"), gr.Image(label="Emotion Visualization"), gr.Textbox(label="AI Response") ], title="Emotional AI Assistant", description="An AI assistant that can analyze the emotional content of text and generate responses based on its emotional state.", ) iface.launch()