Update app.py

app.py

@@ -1,286 +1,106 @@
-import gradio as gr
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
-import re
-
-class HuatuoMedicalAI:
-    def __init__(self):
-        self.model = None
-        self.tokenizer = None
-        self.loaded = False
-        self.conversation_history = []
-        self.question_count = 0
-        self.max_questions = 3
-
-    def load_model(self):
-        """Load HuatuoGPT model"""
-        if self.loaded:
-            return True
-            
-        try:
-            print("🔄 Loading HuatuoGPT-7B Medical AI...")
-            self.tokenizer = AutoTokenizer.from_pretrained(
-                "FreedomIntelligence/HuatuoGPT-7B",
-                trust_remote_code=True
+# app.py
+from flask import Flask, request, jsonify, render_template
+from flask_cors import CORS
+import base64
+import tempfile
+import os
+
+app = Flask(__name__)
+CORS(app)
+
+# Initialize components
+medical_agent = MedicalAgent()
+sign_translator = SignLanguageTranslator()
+sign_generator = SignLanguageGenerator()
+speech_processor = SpeechProcessor()
+
+# Add sample medical knowledge
+medical_knowledge = [
+    "Headache can be caused by tension, migraine, or sinus issues",
+    "Common headache symptoms include throbbing pain, sensitivity to light",
+    "Headache duration and location help diagnose the type",
+    "Migraine often includes nausea and light sensitivity",
+    "Tension headaches typically cause band-like pressure around head"
+]
+medical_agent.rag.add_medical_knowledge(medical_knowledge)
+
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+@app.route('/api/process_sign_language', methods=['POST'])
+def process_sign_language():
+    """Process sign language video and return agent response"""
+    try:
+        video_data = request.json['video_data']  # Base64 encoded video frame
+        frame = decode_video_frame(video_data)
+        
+        # Convert sign language to text
+        patient_text = sign_translator.process_video_frame(frame)
+        
+        # Process with medical agent
+        agent_response = medical_agent.process_patient_input(patient_text)
+        
+        if agent_response['type'] == 'question':
+            # Generate sign language for the question
+            sign_animation = sign_generator.text_to_sign_animation(
+                agent_response['content']
             )
-            self.model = AutoModelForCausalLM.from_pretrained(
-                "FreedomIntelligence/HuatuoGPT-7B",
-                torch_dtype=torch.float16,
-                device_map="auto",
-                trust_remote_code=True
+            return jsonify({
+                'type': 'question',
+                'text': agent_response['content'],
+                'sign_animation': sign_animation,
+                'question_count': agent_response['question_count']
+            })
+        else:
+            # Send summary to doctor via TTS
+            tts_audio = speech_processor.text_to_speech(
+                agent_response['content'],
+                "summary.wav"
             )
-            self.loaded = True
-            print("✅ HuatuoGPT-7B Medical AI Ready!")
-            return True
-        except Exception as e:
-            print(f"❌ Error loading HuatuoGPT: {e}")
-            return False
-
-    def needs_clarification(self, message):
-        """Check if patient message needs clarification"""
-        message = message.strip().lower()
-        
-        # Very short or unclear messages need clarification
-        if len(message) < 3:
-            return True
+            return jsonify({
+                'type': 'summary',
+                'text': agent_response['content'],
+                'audio': tts_audio
+            })
             
-        if len(message.split()) <= 2 and len(message) < 15:
-            vague_terms = ['help', 'pain', 'sick', 'problem', 'issue', '?']
-            if any(term in message for term in vague_terms):
-                return True
-                
-        return False
-
-    def generate_medical_question(self, user_message):
-        """Generate 1-line medical question using HuatuoGPT"""
-        try:
-            # Medical consultation prompt for HuatuoGPT
-            prompt = f"""As a medical doctor, the patient says: "{user_message}"
-            
-What is the most important single question to ask for better diagnosis? 
-Keep it to one line only.
-
-Question:"""
-            
-            inputs = self.tokenizer(prompt, return_tensors="pt", max_length=512, truncation=True)
-            
-            with torch.no_grad():
-                outputs = self.model.generate(
-                    inputs.input_ids,
-                    max_new_tokens=25,  # Short for 1-line questions
-                    temperature=0.7,
-                    do_sample=True,
-                    top_p=0.9,
-                    repetition_penalty=1.1,
-                    pad_token_id=self.tokenizer.eos_token_id
-                )
-            
-            response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
-            question = response.split("Question:")[-1].strip()
-            
-            # Clean and ensure 1-line format
-            question = re.sub(r'\n+', ' ', question)  # Remove newlines
-            question = question.split('.')[0]  # Take first sentence only
-            if not question.endswith('?'):
-                question += '?'
-                
-            # Force single line and reasonable length
-            question = question.replace('\n', ' ').strip()
-            if len(question.split()) > 12:
-                question = ' '.join(question.split()[:12]) + '?'
-                
-            return question
-            
-        except Exception as e:
-            # Fallback questions
-            fallback_questions = [
-                "How long have you had these symptoms?",
-                "Where exactly is the pain located?",
-                "Can you rate the severity from 1-10?",
-                "Any other symptoms you're experiencing?"
-            ]
-            import random
-            return random.choice(fallback_questions)
-
-    def get_final_medical_report(self):
-        """Generate final medical report after 3 questions"""
-        context = "\n".join(self.conversation_history)
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/api/process_doctor_audio', methods=['POST'])
+def process_doctor_audio():
+    """Process doctor's audio question"""
+    try:
+        audio_data = request.json['audio_data']
         
-        prompt = f"""Based on this medical conversation:
-
-{context}
-
-As Doctor HuatuoGPT, provide a comprehensive medical assessment including:
-1. Possible diagnosis based on symptoms
-2. Immediate self-care recommendations  
-3. When to seek urgent medical attention
-4. General health advice
-
-Keep the response professional, clear, and helpful.
-
-Medical Assessment:"""
+        # Save audio temporarily
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as f:
+            f.write(base64.b64decode(audio_data))
+            audio_path = f.name
         
-        try:
-            inputs = self.tokenizer(prompt, return_tensors="pt", max_length=1024, truncation=True)
-            
-            with torch.no_grad():
-                outputs = self.model.generate(
-                    inputs.input_ids,
-                    max_new_tokens=400,
-                    temperature=0.3,
-                    do_sample=True,
-                    top_p=0.8,
-                    repetition_penalty=1.1,
-                    pad_token_id=self.tokenizer.eos_token_id
-                )
-            
-            response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
-            assessment = response.split("Medical Assessment:")[-1].strip()
-            
-            # Add standard medical disclaimer
-            assessment += "\n\n⚠️ **Medical Disclaimer**: This is AI-generated advice. Please consult a healthcare professional for proper diagnosis and treatment."
-            
-            return assessment
-            
-        except Exception as e:
-            return "Based on our conversation, I recommend consulting a healthcare professional for proper medical evaluation and treatment."
-
-    def process_patient_message(self, message):
-        """Main function to handle patient messages"""
-        if not self.loaded:
-            success = self.load_model()
-            if not success:
-                return "🔄 Medical AI is loading... Please wait.", 0, 3
-                
-        # Add patient message to conversation
-        self.conversation_history.append(f"Patient: {message}")
-        self.question_count += 1
+        # Convert speech to text
+        doctor_text = speech_processor.speech_to_text(audio_path)
         
-        # Check if we need more clarification (max 3 questions)
-        if self.needs_clarification(message) and self.question_count < self.max_questions:
-            question = self.generate_medical_question(message)
-            self.conversation_history.append(f"Doctor: {question}")
-            return question, self.question_count, self.max_questions
-        else:
-            # Generate final medical report
-            final_report = self.get_final_medical_report()
-            self.conversation_history.append(f"Doctor: {final_report}")
-            
-            # Reset for next conversation
-            self.question_count = 0
-            self.conversation_history = []
-            
-            return final_report, 0, self.max_questions
-
-# Initialize the medical AI
-medical_ai = HuatuoMedicalAI()
-
-def chat_interface(message, chat_history, question_count):
-    """Gradio chat interface"""
-    if not message.strip():
-        return "", chat_history, question_count
-    
-    # Process patient message
-    response, new_count, max_questions = medical_ai.process_patient_message(message)
-    
-    # Add to chat history
-    chat_history.append((message, response))
-    
-    return "", chat_history, new_count
-
-def clear_conversation():
-    """Clear conversation and reset counters"""
-    medical_ai.conversation_history = []
-    medical_ai.question_count = 0
-    return [], 0
-
-# FIXED: Removed theme parameter
-with gr.Blocks(title="HuatuoGPT Medical Assistant") as demo:
-    gr.Markdown("""
-    # 🩺 HuatuoGPT Medical Assistant
-    **AI-Powered Medical Consultation • 3 Questions Max • Professional Medical Advice**
-    
-    *Patient describes symptoms → AI asks clarifying questions → Final medical assessment*
-    """)
-    
-    # Question counter
-    question_counter = gr.Textbox(
-        label="Clarification Questions",
-        value="0/3",
-        interactive=False,
-        max_lines=1
-    )
-    
-    # Chat interface
-    chatbot = gr.Chatbot(
-        label="Medical Consultation",
-        height=500
-    )
-    
-    with gr.Row():
-        # Patient input - can be any length
-        msg = gr.Textbox(
-            label="Describe Your Symptoms",
-            placeholder="Example: headache for 2 days with sensitivity to light...",
-            lines=3,
-            scale=4
-        )
-        send_btn = gr.Button("🚀 Send to Doctor", scale=1, variant="primary")
-    
-    with gr.Row():
-        clear_btn = gr.Button("🔄 New Consultation")
-        status = gr.Textbox(
-            label="Status",
-            value="HuatuoGPT-7B Medical AI - Ready for Consultation",
-            interactive=False,
-            max_lines=2
-        )
-    
-    # Hidden state for question count
-    current_count = gr.State(0)
-    
-    def update_counter(question_count, max_questions=3):
-        """Update question counter display"""
-        return f"{question_count}/{max_questions}"
-    
-    def respond(message, chat_history, question_count):
-        """Handle user response"""
-        if not message.strip():
-            return message, chat_history, question_count
+        # Process with agent
+        patient_question = medical_agent.process_doctor_question(doctor_text)
+        
+        # Generate sign language
+        sign_animation = sign_generator.text_to_sign_animation(patient_question)
         
-        response, new_count, max_questions = medical_ai.process_patient_message(message)
-        chat_history.append((message, response))
+        os.unlink(audio_path)  # Clean up
         
-        return "", chat_history, new_count
-    
-    # Connect all components
-    msg.submit(
-        respond,
-        [msg, chatbot, current_count],
-        [msg, chatbot, current_count]
-    ).then(
-        update_counter,
-        [current_count],
-        [question_counter]
-    )
-    
-    send_btn.click(
-        respond,
-        [msg, chatbot, current_count],
-        [msg, chatbot, current_count]
-    ).then(
-        update_counter,
-        [current_count],
-        [question_counter]
-    )
-    
-    clear_btn.click(
-        clear_conversation,
-        outputs=[chatbot, current_count]
-    ).then(
-        lambda: ("", "0/3"),
-        outputs=[msg, question_counter]
-    )
+        return jsonify({
+            'question': patient_question,
+            'sign_animation': sign_animation
+        })
+        
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+def decode_video_frame(video_data):
+    """Decode base64 video frame"""
+    # Implementation depends on your frontend format
+    pass
 
-if __name__ == "__main__":
-    demo.launch(share=False)
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=5000, debug=True)