Spaces:
Running
Running
| import warnings | |
| import numpy as np | |
| import pandas as pd | |
| import os | |
| import json | |
| import random | |
| import gradio as gr | |
| import torch | |
| import torch.nn as nn | |
| import torch.optim as optim | |
| from torch.utils.data import DataLoader, IterableDataset | |
| from sklearn.ensemble import IsolationForest, RandomForestClassifier | |
| from sklearn.model_selection import train_test_split | |
| from sklearn.preprocessing import OneHotEncoder | |
| from sklearn.neural_network import MLPClassifier | |
| from deap import base, creator, tools, algorithms | |
| from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline, AutoModelForSequenceClassification | |
| import gc | |
| import multiprocessing as mp | |
| from joblib import Parallel, delayed | |
| warnings.filterwarnings('ignore', category=FutureWarning, module='huggingface_hub.file_download') | |
| # Initialize Example Emotions Dataset | |
| 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") | |
| # Lazy loading for the fine-tuned language model | |
| _finetuned_lm_tokenizer = None | |
| _finetuned_lm_model = None | |
| def get_finetuned_lm_model(): | |
| global _finetuned_lm_tokenizer, _finetuned_lm_model | |
| if _finetuned_lm_tokenizer is None or _finetuned_lm_model is None: | |
| finetuned_lm_model_name = "microsoft/DialoGPT-large" # Replace with your fine-tuned language model name | |
| _finetuned_lm_tokenizer = AutoTokenizer.from_pretrained(finetuned_lm_model_name) | |
| _finetuned_lm_model = AutoModelForCausalLM.from_pretrained(finetuned_lm_model_name, device_map="auto", low_cpu_mem_usage=True) | |
| return _finetuned_lm_tokenizer, _finetuned_lm_model | |
| # 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} | |
| } | |
| 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): | |
| emotions['ideal_state']['percentage'] -= percentage | |
| emotions[emotion]['percentage'] += percentage | |
| emotions[emotion]['intensity'] = intensity | |
| 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() | |
| # Memory-efficient genetic algorithm for emotion evolution | |
| def evolve_emotions(): | |
| def evaluate(individual): | |
| ideal_state = individual[-1] | |
| other_emotions = individual[:-1] | |
| intensities = individual[-21:-1] | |
| return (abs(ideal_state - 100), | |
| sum(other_emotions), | |
| max(intensities) - min(intensities)) | |
| creator.create("FitnessMulti", base.Fitness, weights=(-1.0, -1.0, -1.0)) | |
| creator.create("Individual", list, fitness=creator.FitnessMulti) | |
| 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) + | |
| (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[-21:-1] | |
| ideal_state = best_individual[-1] | |
| for i, emotion in enumerate(emotions): | |
| emotions[emotion]['percentage'] = emotion_values[i] | |
| emotions[emotion]['intensity'] = intensities[i] | |
| emotions['ideal_state']['percentage'] = ideal_state | |
| def predict_emotion(context): | |
| emotion_prediction_pipeline = pipeline('text-classification', model=emotion_prediction_model, tokenizer=emotion_prediction_tokenizer, top_k=None) | |
| predictions = emotion_prediction_pipeline(context) | |
| emotion_scores = predictions[0] | |
| emotion_pred = emotion_classes[np.argmax(emotion_scores)] | |
| return emotion_pred | |
| def generate_text(prompt, max_length=100, emotion=None): | |
| finetuned_lm_tokenizer, finetuned_lm_model = get_finetuned_lm_model() | |
| input_ids = finetuned_lm_tokenizer.encode(prompt, return_tensors='pt').to(finetuned_lm_model.device) | |
| if emotion is not None: | |
| emotion_intensity = emotions[emotion]['intensity'] | |
| top_p = 0.95 - (emotion_intensity / 10) # Adjust top_p based on emotion intensity | |
| temperature = 0.7 + (emotion_intensity / 5) # Adjust temperature based on emotion intensity | |
| else: | |
| top_p = 0.95 | |
| temperature = 0.7 | |
| with torch.no_grad(): | |
| output = finetuned_lm_model.generate( | |
| input_ids, | |
| max_length=max_length, | |
| num_return_sequences=1, | |
| no_repeat_ngram_size=2, | |
| do_sample=True, | |
| top_k=50, | |
| top_p=top_p, | |
| temperature=temperature | |
| ) | |
| generated_text = finetuned_lm_tokenizer.decode(output[0], skip_special_tokens=True) | |
| return generated_text | |
| def generate_response(context, emotion=None): | |
| prompt = context | |
| generated_text = generate_text(prompt, emotion=emotion) | |
| return generated_text | |
| with gr.Blocks() as demo: | |
| gr.Markdown("# Emotion-Aware Language Model") | |
| context_input = gr.Textbox(label="Enter a context") | |
| predict_btn = gr.Button("Predict Emotion and Generate Text") | |
| with gr.Row(): | |
| emotion_output = gr.Textbox(label="Predicted Emotion", show_label=True) | |
| generated_text_output = gr.Textbox(label="Generated Text", show_label=True) | |
| predict_btn.click(fn=lambda context: (predict_emotion(context), generate_response(context, emotion=predict_emotion(context))), inputs=context_input, outputs=[emotion_output, generated_text_output]) | |
| demo.launch(share=True) |