Add missing gradio_app.py file

gradio_app.py

@@ -0,0 +1,339 @@
+import os
+import logging
+import time
+import asyncio
+from typing import List, Optional, Dict, Any
+import threading
+
+import torch
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+import gradio as gr
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Global variables for model and tokenizer
+model = None
+tokenizer = None
+device = None
+model_loaded = False
+
+class ModelManager:
+    def __init__(self):
+        self.model = None
+        self.tokenizer = None
+        self.device = None
+        self.model_loaded = False
+        self.load_model()
+
+    def load_model(self):
+        """Load the model and tokenizer"""
+        try:
+            logger.info("Starting model loading...")
+            
+            # Check if CUDA is available
+            self.device = "cuda" if torch.cuda.is_available() else "cpu"
+            logger.info(f"Using device: {self.device}")
+            
+            if self.device == "cuda":
+                logger.info(f"GPU: {torch.cuda.get_device_name(0)}")
+                logger.info(f"VRAM Available: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB")
+            
+            # Get HF token from environment
+            hf_token = os.getenv("HF_TOKEN")
+            
+            logger.info("Loading FLAN-T5-Large model...")
+            base_model_name = "google/flan-t5-large"
+            
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                base_model_name,
+                use_fast=True,
+                trust_remote_code=True,
+                token=hf_token
+            )
+            
+            self.model = AutoModelForSeq2SeqLM.from_pretrained(
+                base_model_name,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                device_map="auto" if self.device == "cuda" else None,
+                trust_remote_code=True,
+                low_cpu_mem_usage=True,
+                token=hf_token
+            )
+            
+            if self.device == "cuda":
+                self.model = self.model.to(self.device)
+            
+            self.model_loaded = True
+            logger.info("Model loaded successfully!")
+            
+        except Exception as e:
+            logger.error(f"Error loading model: {str(e)}")
+            raise
+
+    def generate_questions(self, statement: str, num_questions: int = 5, difficulty: str = "mixed", temperature: float = 0.8) -> List[str]:
+        """Generate questions from a statement"""
+        if not self.model_loaded:
+            return ["Model not loaded yet. Please wait..."]
+        
+        try:
+            difficulty_instruction = {
+                "easy": "simple, straightforward questions that test basic understanding",
+                "medium": "questions that require some analysis and comprehension", 
+                "hard": "complex questions that require deep thinking and reasoning",
+                "mixed": "a mix of easy, medium, and hard questions"
+            }
+            
+            # Create prompt optimized for T5
+            prompt = f"""Generate {num_questions} {difficulty_instruction[difficulty]} about this statement:
+
+"{statement}"
+
+Requirements:
+- Clear, well-formed questions
+- Vary question types (what, how, why, when, where)
+- Number each question (1., 2., 3., etc.)
+- End each question with a question mark
+
+Questions:"""
+            
+            # Generate questions
+            inputs = self.tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512)
+            if self.device == "cuda":
+                inputs = inputs.to(self.device)
+            
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    **inputs,
+                    max_new_tokens=512,
+                    temperature=temperature,
+                    top_p=0.95,
+                    do_sample=True,
+                    num_beams=1,
+                    early_stopping=True
+                )
+            
+            # Decode the generated text
+            generated_text = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            
+            # Extract questions
+            questions = self.extract_questions(generated_text)
+            
+            # Ensure we have the requested number of questions
+            questions = questions[:num_questions]
+            
+            # If we don't have enough questions, add fallbacks
+            while len(questions) < num_questions:
+                questions.append(f"What is the main point of this statement: '{statement[:100]}...'?")
+            
+            return questions
+            
+        except Exception as e:
+            logger.error(f"Error generating questions: {str(e)}")
+            return [f"Error generating questions: {str(e)}"]
+
+    def extract_questions(self, generated_text: str) -> List[str]:
+        """Extract questions from the generated text"""
+        questions = []
+        lines = generated_text.split('\n')
+        
+        for line in lines:
+            line = line.strip()
+            # Look for numbered questions
+            if line and (line[0].isdigit() or line.startswith('Q')):
+                # Remove numbering and clean up
+                question = line
+                # Remove common prefixes
+                for prefix in ['1.', '2.', '3.', '4.', '5.', '6.', '7.', '8.', '9.', '10.', 
+                             'Q1:', 'Q2:', 'Q3:', 'Q4:', 'Q5:', 'Question 1:', 'Question 2:', 
+                             'Question 3:', 'Question 4:', 'Question 5:']:
+                    if question.startswith(prefix):
+                        question = question[len(prefix):].strip()
+                        break
+                
+                if question and question.endswith('?'):
+                    questions.append(question)
+        
+        # If no numbered questions found, try to extract any questions
+        if not questions:
+            for line in lines:
+                line = line.strip()
+                if line.endswith('?') and len(line) > 10:
+                    questions.append(line)
+        
+        return questions
+
+# Initialize model manager
+model_manager = ModelManager()
+
+def chat_with_model(message, history, num_questions, difficulty, temperature):
+    """Main chat function for Gradio interface"""
+    if not message.strip():
+        return history, ""
+    
+    # Add user message to history
+    history.append([message, None])
+    
+    # Generate questions
+    questions = model_manager.generate_questions(
+        statement=message,
+        num_questions=num_questions,
+        difficulty=difficulty,
+        temperature=temperature
+    )
+    
+    # Format response
+    if questions:
+        response = "Here are the questions I generated based on your statement:\n\n"
+        for i, question in enumerate(questions, 1):
+            response += f"{i}. {question}\n"
+    else:
+        response = "I couldn't generate questions from that statement. Please try rephrasing it."
+    
+    # Add bot response to history
+    history[-1][1] = response
+    
+    return history, ""
+
+def clear_chat():
+    """Clear the chat history"""
+    return [], ""
+
+# Custom CSS for ChatGPT-like styling
+css = """
+#chatbot {
+    height: 600px;
+}
+
+.gradio-container {
+    max-width: 1200px !important;
+    margin: auto;
+}
+
+#component-0 {
+    height: 100vh;
+}
+
+.chat-message {
+    padding: 10px;
+    margin: 5px 0;
+    border-radius: 10px;
+}
+
+.user-message {
+    background-color: #e3f2fd;
+    margin-left: 20%;
+}
+
+.bot-message {
+    background-color: #f5f5f5;
+    margin-right: 20%;
+}
+"""
+
+# Create Gradio interface
+with gr.Blocks(css=css, title="Question Generation AI", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # 🤖 Question Generation AI
+        ### Powered by FLAN-T5-Large
+        
+        Enter any statement or text, and I'll generate thoughtful questions about it. Perfect for creating study materials, assessments, or exploring topics deeper!
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column(scale=4):
+            chatbot = gr.Chatbot(
+                elem_id="chatbot",
+                label="Chat",
+                show_label=False,
+                avatar_images=(None, "🤖"),
+                bubble_full_width=False,
+                show_share_button=False
+            )
+            
+            with gr.Row():
+                msg = gr.Textbox(
+                    placeholder="Enter a statement or topic to generate questions about...",
+                    show_label=False,
+                    scale=4,
+                    container=False
+                )
+                submit_btn = gr.Button("Generate Questions", variant="primary", scale=1)
+            
+            with gr.Row():
+                clear_btn = gr.Button("Clear Chat", variant="secondary")
+        
+        with gr.Column(scale=1, min_width=300):
+            gr.Markdown("### ⚙️ Settings")
+            
+            num_questions = gr.Slider(
+                minimum=1,
+                maximum=10,
+                value=5,
+                step=1,
+                label="Number of Questions",
+                info="How many questions to generate"
+            )
+            
+            difficulty = gr.Radio(
+                choices=["easy", "medium", "hard", "mixed"],
+                value="mixed",
+                label="Difficulty Level",
+                info="Choose the complexity of questions"
+            )
+            
+            temperature = gr.Slider(
+                minimum=0.1,
+                maximum=2.0,
+                value=0.8,
+                step=0.1,
+                label="Creativity",
+                info="Higher = more creative questions"
+            )
+            
+            gr.Markdown("### 💡 Tips")
+            gr.Markdown(
+                """
+                - **Be specific**: Detailed statements produce better questions
+                - **Try different difficulties**: Easy for basic recall, hard for analysis
+                - **Adjust creativity**: Higher values for more diverse questions
+                - **Examples to try**:
+                  - "Photosynthesis converts sunlight into chemical energy"
+                  - "The American Civil War lasted from 1861 to 1865"
+                  - "Machine learning algorithms learn from data patterns"
+                """
+            )
+    
+    # Event handlers
+    def respond(message, history, num_q, diff, temp):
+        return chat_with_model(message, history, num_q, diff, temp)
+    
+    msg.submit(respond, [msg, chatbot, num_questions, difficulty, temperature], [chatbot, msg])
+    submit_btn.click(respond, [msg, chatbot, num_questions, difficulty, temperature], [chatbot, msg])
+    clear_btn.click(clear_chat, outputs=[chatbot, msg])
+    
+    # Add footer
+    gr.Markdown(
+        """
+        ---
+        <div style="text-align: center; color: #666; font-size: 0.9em;">
+            Built with ❤️ using Gradio and FLAN-T5-Large • 
+            <a href="/docs" target="_blank">API Documentation</a>
+        </div>
+        """
+    )
+
+if __name__ == "__main__":
+    # Launch Gradio interface
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True,
+        show_tips=False,
+        enable_queue=True,
+        max_threads=10
+    )