import warnings import numpy as np import pandas as pd import os import json import random import gradio as gr import torch from sklearn.model_selection import train_test_split 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 textblob import TextBlob import spacy 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) def download_spacy_model(): subprocess.check_call([sys.executable, "-m", "spacy", "download", "en_core_web_sm"]) try: import spacy try: nlp = spacy.load("en_core_web_sm") except OSError: print("Downloading spaCy model...") download_spacy_model() nlp = spacy.load("en_core_web_sm") except ImportError: print("Error: Unable to import spaCy. NLP features will be disabled.") nlp = None def extract_entities(text): if nlp is None: return [] doc = nlp(text) entities = [(ent.text, ent.label_) for ent in doc.ents] return entities # Initialize Example Dataset (For Emotion Prediction) data = { 'context': [ 'I am happy', 'I am sad', 'I am angry', 'I am excited', 'I am calm', 'I am feeling joyful', 'I am grieving', 'I am feeling peaceful', 'I am frustrated', 'I am determined', 'I feel resentment', 'I am feeling glorious', 'I am motivated', 'I am surprised', 'I am fearful', 'I am trusting', 'I feel disgust', 'I am optimistic', 'I am pessimistic', 'I feel bored', 'I am envious' ], '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) 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 LLM model and tokenizer for response generation with increased context window response_model_name = "microsoft/DialoGPT-medium" response_tokenizer = AutoTokenizer.from_pretrained(response_model_name) response_model = AutoModelForCausalLM.from_pretrained(response_model_name) # Enhanced Emotional States emotions = { 'joy': {'percentage': 10, 'motivation': 'positive', 'intensity': 0}, 'pleasure': {'percentage': 10, 'motivation': 'selfish', 'intensity': 0}, 'sadness': {'percentage': 10, 'motivation': 'negative', 'intensity': 0}, 'grief': {'percentage': 10, 'motivation': 'negative', 'intensity': 0}, 'anger': {'percentage': 10, 'motivation': 'traumatic or strong', 'intensity': 0}, 'calmness': {'percentage': 10, 'motivation': 'neutral', 'intensity': 0}, 'determination': {'percentage': 10, 'motivation': 'positive', 'intensity': 0}, 'resentment': {'percentage': 10, 'motivation': 'negative', 'intensity': 0}, 'glory': {'percentage': 10, 'motivation': 'positive', 'intensity': 0}, 'motivation': {'percentage': 10, 'motivation': 'positive', 'intensity': 0}, 'ideal_state': {'percentage': 100, 'motivation': 'balanced', 'intensity': 0}, 'fear': {'percentage': 10, 'motivation': 'defensive', 'intensity': 0}, 'surprise': {'percentage': 10, 'motivation': 'unexpected', 'intensity': 0}, 'anticipation': {'percentage': 10, 'motivation': 'predictive', 'intensity': 0}, 'trust': {'percentage': 10, 'motivation': 'reliable', 'intensity': 0}, 'disgust': {'percentage': 10, 'motivation': 'repulsive', 'intensity': 0}, 'optimism': {'percentage': 10, 'motivation': 'hopeful', 'intensity': 0}, 'pessimism': {'percentage': 10, 'motivation': 'doubtful', 'intensity': 0}, 'boredom': {'percentage': 10, 'motivation': 'indifferent', 'intensity': 0}, 'envy': {'percentage': 10, 'motivation': 'jealous', 'intensity': 0}, 'neutral': {'percentage': 10, 'motivation': 'balanced', 'intensity': 0}, 'wit': {'percentage': 15, 'motivation': 'clever', 'intensity': 0}, 'curiosity': {'percentage': 20, 'motivation': 'inquisitive', 'intensity': 0}, } total_percentage = 200 emotion_history_file = 'emotion_history.json' 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): if percentage > emotions['ideal_state']['percentage']: percentage = emotions['ideal_state']['percentage'] emotions['ideal_state']['percentage'] -= percentage emotions[emotion]['percentage'] += percentage emotions[emotion]['intensity'] = intensity # Introduce some randomness in emotional evolution for e in emotions: if e != emotion and e != 'ideal_state': change = random.uniform(-2, 2) emotions[e]['percentage'] = max(0, emotions[e]['percentage'] + change) total_current = sum(e['percentage'] for e in emotions.values()) adjustment = total_percentage - total_current emotions['ideal_state']['percentage'] += adjustment def normalize_context(context): return context.lower().strip() # Create FitnessMulti and Individual outside of evolve_emotions 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) - 1] intensities = individual[len(emotions) - 1:-1] ideal_state = individual[-1] ideal_diff = abs(100 - ideal_state) sum_non_ideal = sum(emotion_values) intensity_range = max(intensities) - min(intensities) return ideal_diff, sum_non_ideal, intensity_range def evolve_emotions(): toolbox = base.Toolbox() toolbox.register("attr_float", random.uniform, 0, 20) toolbox.register("attr_intensity", random.uniform, 0, 10) toolbox.register("individual", tools.initCycle, creator.Individual, (toolbox.attr_float,) * (len(emotions) - 1) + (toolbox.attr_intensity,) * (len(emotions) - 1) + (lambda: 100,), 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=100, stats=None, halloffame=None, verbose=False) best_individual = tools.selBest(population, k=1)[0] emotion_values = best_individual[:len(emotions) - 1] intensities = best_individual[len(emotions) - 1:-1] ideal_state = best_individual[-1] for i, (emotion, data) in enumerate(list(emotions.items())[:-1]): # Exclude 'ideal_state' if i < len(emotion_values): data['percentage'] = emotion_values[i] if i < len(intensities): data['intensity'] = intensities[i] emotions['ideal_state']['percentage'] = ideal_state def update_emotion_history(emotion, percentage, intensity, context): entry = { 'emotion': emotion, 'percentage': percentage, 'intensity': intensity, 'context': context, 'timestamp': pd.Timestamp.now().isoformat() } emotion_history.append(entry) save_historical_data(emotion_history) # Adding 443 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 generate_response(input_text): inputs = response_tokenizer(input_text, return_tensors="pt", truncation=True, max_length=512) with torch.no_grad(): response_ids = response_model.generate( inputs.input_ids, max_length=150, num_return_sequences=1, no_repeat_ngram_size=2, top_k=50, top_p=0.95, temperature=0.7 ) response = response_tokenizer.decode(response_ids[0], skip_special_tokens=True) return response 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): doc = nlp(text) entities = [(ent.text, ent.label_) for ent in doc.ents] 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 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('Current Emotional State') plt.xticks(rotation=45, ha='right') plt.tight_layout() plt.savefig('emotional_state.png') plt.close() return 'emotional_state.png' def interactive_interface(input_text): try: evolve_emotions() predicted_emotion = predict_emotion(input_text) sentiment_scores = sentiment_analysis(input_text) entities = extract_entities(input_text) text_complexity = analyze_text_complexity(input_text) update_emotion(predicted_emotion, random.uniform(5, 15), random.uniform(0, 10)) update_emotion_history(predicted_emotion, emotions[predicted_emotion]['percentage'], emotions[predicted_emotion]['intensity'], input_text) feature_transformations() response = generate_response(input_text) emotion_visualization = visualize_emotions() analysis_result = { 'predicted_emotion': predicted_emotion, 'sentiment_scores': sentiment_scores, 'entities': entities, 'text_complexity': text_complexity, 'current_emotional_state': emotions, 'response': response, 'emotion_visualization': emotion_visualization } return analysis_result except Exception as e: print(f"An error occurred: {str(e)}") return "I apologize, but I encountered an error while processing your input. Please try again." def gradio_interface(input_text): response = interactive_interface(input_text) if isinstance(response, str): return response else: return ( f"Predicted Emotion: {response['predicted_emotion']}\n" f"Sentiment: {response['sentiment_scores']}\n" f"Entities: {response['entities']}\n" f"Text Complexity: {response['text_complexity']}\n" f"Response: {response['response']}\n" f"Emotion Visualization: {response['emotion_visualization']}" ) # Create Gradio interface iface = gr.Interface( fn=gradio_interface, inputs="text", outputs=["text", gr.Image(type="filepath")], title="Enhanced Emotional AI Interface", description="Enter text to interact with the AI and analyze emotions." ) if __name__ == "__main__": iface.launch()