Update app.py

app.py

@@ -1,202 +1,154 @@
 import warnings
 import os
-import json
 import random
 import gradio as gr
 import torch
+import pandas as pd
 import matplotlib.pyplot as plt
 import seaborn as sns
-import pandas as pd
 import nltk
 from nltk.sentiment import SentimentIntensityAnalyzer
 from textblob import TextBlob
-from transformers import AutoModelForSequenceClassification, AutoTokenizer, AutoModelForCausalLM, LlamaConfig
+from transformers import (
+    AutoTokenizer,
+    AutoModelForCausalLM,
+    AutoModelForSequenceClassification,
+)
 
+# Suppress warnings and fix Gradio schema bug
 warnings.filterwarnings('ignore', category=FutureWarning)
-
-# --- Monkey Patch for Gradio Client JSON Schema Bug ---
-import gradio_client.utils as client_utils
-
-original_get_type = client_utils.get_type
-def patched_get_type(schema):
-    if not isinstance(schema, dict):
-        return type(schema).__name__
-    return original_get_type(schema)
-client_utils.get_type = patched_get_type
-
-if not hasattr(client_utils, "_original_json_schema_to_python_type"):
-    client_utils._original_json_schema_to_python_type = client_utils._json_schema_to_python_type
-
-def patched_json_schema_to_python_type(schema, defs=None):
-    if isinstance(schema, bool):
-        return "bool"
-    return client_utils._original_json_schema_to_python_type(schema, defs)
-client_utils._json_schema_to_python_type = patched_json_schema_to_python_type
-# --- End of Monkey Patch ---
-
-# Download necessary NLTK data
 nltk.download('vader_lexicon', quiet=True)
 
-# ---------------------------
-# Backend Support for GGUF Models
-# ---------------------------
-try:
-    from llama_cpp import Llama
-    BACKEND = "llama_cpp"
-except ImportError:
-    BACKEND = "transformers"
-
-# ---------------------------
-# Emotional Analysis Module
-# ---------------------------
+# --- Emotion Analyzer ---
 class EmotionalAnalyzer:
     def __init__(self):
-        self.emotion_model = AutoModelForSequenceClassification.from_pretrained(
+        self.model = AutoModelForSequenceClassification.from_pretrained(
             "bhadresh-savani/distilbert-base-uncased-emotion"
         )
-        self.emotion_tokenizer = AutoTokenizer.from_pretrained(
+        self.tokenizer = AutoTokenizer.from_pretrained(
             "bhadresh-savani/distilbert-base-uncased-emotion"
         )
-        self.emotion_labels = ["sadness", "joy", "love", "anger", "fear", "surprise"]
+        self.labels = ["sadness", "joy", "love", "anger", "fear", "surprise"]
         self.sia = SentimentIntensityAnalyzer()
 
     def predict_emotion(self, text):
-        inputs = self.emotion_tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
+        inputs = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
         with torch.no_grad():
-            outputs = self.emotion_model(**inputs)
-        probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
-        predicted_idx = torch.argmax(probabilities, dim=-1).item()
-        return self.emotion_labels[predicted_idx]
-
-    def sentiment_analysis(self, text):
-        return self.sia.polarity_scores(text)
+            outputs = self.model(**inputs)
+        probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
+        return self.labels[torch.argmax(probs).item()]
 
-    def detailed_emotional_analysis(self, text):
-        vader_scores = self.sentiment_analysis(text)
+    def analyze(self, text):
+        vader_scores = self.sia.polarity_scores(text)
         blob = TextBlob(text)
-        textblob_analysis = {
-            'polarity': blob.sentiment.polarity,
-            'subjectivity': blob.sentiment.subjectivity,
-            'word_count': len(blob.words),
-            'sentence_count': len(blob.sentences)
+        blob_data = {
+            "polarity": blob.sentiment.polarity,
+            "subjectivity": blob.sentiment.subjectivity,
+            "word_count": len(blob.words),
+            "sentence_count": len(blob.sentences),
         }
-        predicted_emotion = self.predict_emotion(text)
         return {
-            'predicted_emotion': predicted_emotion,
-            'vader': vader_scores,
-            'textblob': textblob_analysis
+            "emotion": self.predict_emotion(text),
+            "vader": vader_scores,
+            "textblob": blob_data,
         }
 
-    def visualize_emotions(self, emotions_dict):
-        emotions_df = pd.DataFrame(list(emotions_dict.items()), columns=['Emotion', 'Percentage'])
+    def plot_emotions(self):
+        simulated_emotions = {
+            "joy": random.randint(10, 30),
+            "sadness": random.randint(5, 20),
+            "anger": random.randint(10, 25),
+            "fear": random.randint(5, 15),
+            "love": random.randint(10, 30),
+            "surprise": random.randint(5, 20),
+        }
+        df = pd.DataFrame(list(simulated_emotions.items()), columns=["Emotion", "Percentage"])
         plt.figure(figsize=(8, 4))
-        sns.barplot(x='Emotion', y='Percentage', data=emotions_df)
-        plt.title('Current Emotional State')
+        sns.barplot(x="Emotion", y="Percentage", data=df)
+        plt.title("Simulated Emotional State")
         plt.tight_layout()
-        image_path = 'emotional_state.png'
-        plt.savefig(image_path)
+        path = "emotions.png"
+        plt.savefig(path)
         plt.close()
-        return image_path
-
-# ---------------------------
-# LLM Response Generator Module
-# ---------------------------
-class LLMResponder:
-    def __init__(self, model_name="SicariusSicariiStuff/Impish_LLAMA_3B_GGUF"):
-        self.model_name = model_name
-        if BACKEND == "llama_cpp":
-            # Replace with the actual path to your GGUF file.
-            self.llm = Llama(model_path="path/to/your/gguf/file.gguf", n_ctx=1024)
-            self.backend = "llama_cpp"
-        else:
-            # Create a dummy config using LlamaConfig so the model loads despite missing keys.
-            dummy_config = LlamaConfig.from_dict({"model_type": "llama"})
-            try:
-                self.llm_tokenizer = AutoTokenizer.from_pretrained(model_name, config=dummy_config, trust_remote_code=True)
-            except Exception as e:
-                print(f"Error loading tokenizer from {model_name}; using fallback tokenizer.")
-                fallback_model = "sentence-transformers/all-MiniLM-L6-v2"
-                self.llm_tokenizer = AutoTokenizer.from_pretrained(fallback_model, config=dummy_config, trust_remote_code=True)
-            try:
-                self.llm_model = AutoModelForCausalLM.from_pretrained(model_name, config=dummy_config, trust_remote_code=True)
-            except Exception as e:
-                print(f"Error loading model from {model_name}; using fallback model.")
-                fallback_model = "sentence-transformers/all-MiniLM-L6-v2"
-                self.llm_model = AutoModelForCausalLM.from_pretrained(fallback_model, config=dummy_config, trust_remote_code=True)
-            self.backend = "transformers"
-
-    def generate_response(self, prompt):
-        if self.backend == "llama_cpp":
-            result = self.llm(prompt=prompt, max_tokens=256, temperature=0.95, top_p=0.95)
-            response = result.get("response", "")
-        else:
-            inputs = self.llm_tokenizer(prompt, return_tensors="pt", truncation=True, max_length=1024)
-            with torch.no_grad():
-                output_ids = self.llm_model.generate(
-                    inputs.input_ids,
-                    max_length=1024,
-                    do_sample=True,
-                    top_p=0.95,
-                    top_k=50,
-                    pad_token_id=self.llm_tokenizer.eos_token_id
-                )
-            response = self.llm_tokenizer.decode(output_ids[0], skip_special_tokens=True)
-        return response
-
-# ---------------------------
-# Main Interactive Interface Function
-# ---------------------------
-def interactive_interface(input_text):
-    emotion_analyzer = EmotionalAnalyzer()
-    llm_responder = LLMResponder()
-
-    emotional_data = emotion_analyzer.detailed_emotional_analysis(input_text)
-    current_emotions = {
-        'joy': random.randint(10, 30),
-        'sadness': random.randint(5, 20),
-        'anger': random.randint(10, 25),
-        'fear': random.randint(5, 15),
-        'love': random.randint(10, 30),
-        'surprise': random.randint(5, 20)
-    }
-    emotion_image = emotion_analyzer.visualize_emotions(current_emotions)
+        return path
+
+# --- Text Completion LLM ---
+tokenizer = AutoTokenizer.from_pretrained("diabolic6045/ELN-Llama-1B-base")
+model = AutoModelForCausalLM.from_pretrained("diabolic6045/ELN-Llama-1B-base")
+
+def generate_completion(message, temperature, max_length):
+    inputs = tokenizer(message, return_tensors="pt", truncation=True, max_length=512)
+    input_ids = inputs["input_ids"]
+    current_text = message
+
+    for _ in range(max_length - input_ids.shape[1]):
+        with torch.no_grad():
+            outputs = model(input_ids)
+            logits = outputs.logits[:, -1, :] / temperature
+            probs = torch.softmax(logits, dim=-1)
+            next_token = torch.multinomial(probs, num_samples=1)
+
+        if next_token.item() == tokenizer.eos_token_id:
+            break
+
+        input_ids = torch.cat([input_ids, next_token], dim=-1)
+        new_token_text = tokenizer.decode(next_token[0], skip_special_tokens=True)
+        current_text += new_token_text
+        yield current_text
+
+# --- Emotion-Aware LLM Response ---
+def emotion_aware_response(input_text):
+    analyzer = EmotionalAnalyzer()
+    results = analyzer.analyze(input_text)
+    image_path = analyzer.plot_emotions()
 
     prompt = (
         f"Input: {input_text}\n"
-        f"Detected Emotion: {emotional_data['predicted_emotion']}\n"
-        f"VADER Scores: {emotional_data['vader']}\n"
-        "Provide a thoughtful, emotionally aware response that reflects the above data:"
+        f"Detected Emotion: {results['emotion']}\n"
+        f"VADER Scores: {results['vader']}\n"
+        f"Respond thoughtfully and emotionally aware:"
     )
-    llm_response = llm_responder.generate_response(prompt)
-
-    result = {
-        'detailed_emotional_analysis': emotional_data,
-        'llm_response': llm_response,
-        'emotion_visualization': emotion_image
-    }
-    return result
-
-def gradio_interface(input_text):
-    result = interactive_interface(input_text)
-    output_text = (
-        f"Detailed Emotional Analysis:\n"
-        f" - Predicted Emotion: {result['detailed_emotional_analysis']['predicted_emotion']}\n"
-        f" - VADER: {result['detailed_emotional_analysis']['vader']}\n"
-        f" - TextBlob: {result['detailed_emotional_analysis']['textblob']}\n\n"
-        f"LLM Response:\n{result['llm_response']}"
-    )
-    return output_text, result['emotion_visualization']
-
-# ---------------------------
-# Create Gradio Interface
-# ---------------------------
-iface = gr.Interface(
-    fn=gradio_interface,
-    inputs="text",
-    outputs=["text", gr.Image(type="filepath")],
-    title="Enhanced Emotional Analysis with GGUF LLM Support",
-    description="Enter text to perform detailed emotional analysis and generate an emotionally aware response using the Impish_LLAMA_3B_GGUF model."
-)
 
-if __name__ == "__main__":
-    iface.launch()
+    inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512)
+    with torch.no_grad():
+        output_ids = model.generate(
+            inputs.input_ids,
+            max_length=512,
+            do_sample=True,
+            temperature=0.7,
+            top_k=50,
+            top_p=0.95,
+            pad_token_id=tokenizer.eos_token_id
+        )
+    response = tokenizer.decode(output_ids[0], skip_special_tokens=True)
+
+    summary = (
+        f"Emotion: {results['emotion']}\n"
+        f"VADER: {results['vader']}\n"
+        f"TextBlob: {results['textblob']}\n\n"
+        f"LLM Response:\n{response}"
+    )
+    return summary, image_path
+
+# --- Gradio Interface ---
+with gr.Blocks(title="ELN LLaMA 1B Enhanced Demo") as app:
+    gr.Markdown("## 🧠 ELN-LLaMA Emotion-Aware & Completion Interface")
+    
+    with gr.Tab("💬 Emotion-Aware Response"):
+        with gr.Row():
+            input_text = gr.Textbox(label="Input Text", lines=4, placeholder="Type something with emotion or meaning...")
+        with gr.Row():
+            text_output = gr.Textbox(label="Response", lines=8)
+            img_output = gr.Image(label="Emotional Visualization")
+        emotion_btn = gr.Button("Generate Emotion-Aware Response")
+        emotion_btn.click(emotion_aware_response, inputs=input_text, outputs=[text_output, img_output])
+
+    with gr.Tab("📝 Text Completion"):
+        comp_text = gr.Textbox(label="Prompt", lines=4)
+        comp_temp = gr.Slider(minimum=0.1, maximum=1.0, value=0.7, label="Temperature")
+        comp_len = gr.Slider(minimum=50, maximum=500, value=200, step=50, label="Max Length")
+        comp_output = gr.Textbox(label="Generated Completion", lines=8)
+        comp_button = gr.Button("Complete Text")
+        comp_button.click(generate_completion, inputs=[comp_text, comp_temp, comp_len], outputs=comp_output)
+
+app.launch(share=True)