Upload 7 files

README.md

@@ -1,19 +1,119 @@
----
-title: FinalProject
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: deep learning final project
----
-
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+# AI Medical Consultation System
+
+An intelligent medical consultation system built with Streamlit that uses multiple AI models to analyze patient symptoms, assess risk levels, and provide personalized medical recommendations.
+
+## 🚀 Features
+
+- **Natural Language Symptom Description**: Patients describe their symptoms in natural language
+- **Symptom Extraction**: Automatically extracts key symptoms and duration information using BioBERT
+- **Risk Assessment**: Classifies the risk level (Low, Medium, High) using PubMedBERT
+- **Personalized Recommendations**: Generates tailored medical recommendations using a fine-tuned T5 model
+- **User-Friendly Interface**: Clean, intuitive UI with interactive visualizations
+- **Consultation History**: Save and review past consultations
+- **Responsive Design**: Works on desktop and mobile devices
+
+## 📋 System Components
+
+The system consists of three AI models working in a pipeline:
+
+1. **Symptom Extraction Model**: [dmis-lab/biobert-v1.1](https://huggingface.co/dmis-lab/biobert-v1.1)
+   - Identifies symptoms and their duration in the patient's description
+   - Implemented as a Named Entity Recognition (NER) task
+
+2. **Risk Classification Model**: [microsoft/BiomedNLP-PubMedBERT-base-uncased-abstract](https://huggingface.co/microsoft/BiomedNLP-PubMedBERT-base-uncased-abstract)
+   - Classifies the patient's condition into Low, Medium, or High risk
+   - Fine-tuned for medical risk assessment
+
+3. **Recommendation Generation Model**: Fine-tuned T5-small
+   - Generates personalized medical recommendations
+   - Fine-tuned on a dataset of medical advice and recommendations
+
+## 🛠️ Installation
+
+1. Clone this repository:
+```bash
+git clone <repository-url>
+cd medical-consultation-system
+```
+
+2. Install the required packages:
+```bash
+pip install -r requirements.txt
+```
+
+3. Download the fine-tuned T5 model (if not included):
+```bash
+# Instructions for downloading or fine-tuning the T5 model would go here
+# For example:
+# python download_models.py
+```
+
+## 🚀 Usage
+
+1. Run the Streamlit app:
+```bash
+streamlit run app.py
+```
+
+2. Open your web browser and navigate to the URL displayed in your terminal (typically http://localhost:8501)
+
+3. Enter your symptoms in natural language in the text area
+
+4. Click the "Analyze Symptoms" button to process your input
+
+5. Review the results in the various tabs:
+   - **Overview**: Summary of symptoms, risk level, and recommendations
+   - **Symptoms Analysis**: Detailed analysis of extracted symptoms and duration
+   - **Risk Assessment**: Risk level with confidence and explanation
+   - **Recommendations**: Detailed medical recommendations and department suggestions
+
+## 📊 Example
+
+Input:
+```
+I've been experiencing severe headaches and dizziness for about 2 weeks. Sometimes I also feel nauseous.
+```
+
+Output:
+- **Extracted Symptoms**: Headaches, dizziness, nauseous
+- **Duration**: 2 weeks
+- **Risk Level**: Medium
+- **Recommendation**: Personalized guidance on seeking medical attention and home care
+
+## 📁 Project Structure
+
+```
+medical-consultation-system/
+├── app.py                  # Main Streamlit application
+├── models.py               # Model loading and inference code
+├── utils.py                # Helper functions and utilities
+├── style.css               # Custom CSS styling
+├── requirements.txt        # Package dependencies
+├── README.md               # Project documentation
+└── consultation_history/   # Stored consultation records (created on first use)
+```
+
+## ⚠️ Limitations and Disclaimer
+
+- This system is for **informational purposes only** and is not a substitute for professional medical advice, diagnosis, or treatment.
+- The AI models may not capture all symptoms or correctly assess all conditions.
+- Risk assessments and recommendations are based on general patterns and may not be accurate for specific individual cases.
+- Always consult with qualified healthcare providers for medical concerns.
+
+## 🔧 Customization
+
+You can customize the system by:
+- Fine-tuning the models on different or additional datasets
+- Modifying the UI in app.py
+- Adjusting the CSS styling in style.css
+- Adding new features like multilingual support or additional visualization options
+
+## 📝 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## 🙏 Acknowledgements
+
+- [Hugging Face](https://huggingface.co/) for providing access to pre-trained models
+- [Streamlit](https://streamlit.io/) for the web application framework
+- [Plotly](https://plotly.com/) for interactive visualizations 

app.py

@@ -0,0 +1,598 @@
+import streamlit as st
+import pandas as pd
+import time
+import torch
+import os
+from models import MedicalConsultationPipeline
+from utils import (
+    highlight_text_with_entities,
+    format_duration,
+    create_risk_gauge,
+    create_risk_probability_chart,
+    save_consultation,
+    load_consultation_history,
+    init_session_state,
+    RISK_COLORS
+)
+
+# Page configuration
+st.set_page_config(
+    page_title="AI Medical Consultation",
+    page_icon="🩺",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS
+def load_css():
+    with open("style.css", "r") as f:
+        st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
+
+# 检查本地是否有fine-tuned的T5模型
+def find_fine_tuned_model():
+    possible_local_paths = [
+        "./finetuned_t5-small",  # 添加用户提供的微调模型路径
+        "./t5-small-medical-recommendation",
+        "./models/t5-small-medical-recommendation",
+        "./fine_tuned_models/t5-small",
+        "./output",
+        "./fine_tuning_output"
+    ]
+    
+    for path in possible_local_paths:
+        if os.path.exists(path):
+            return path
+    
+    return "t5-small"  # 如果没有找到，返回基础模型
+
+# Initialize session state
+init_session_state()
+
+# Apply custom CSS
+load_css()
+
+# Sidebar for settings and history
+with st.sidebar:
+    st.image("https://img.icons8.com/fluency/96/000000/hospital-3.png", width=80)
+    st.title("AI Medical Assistant")
+    
+    st.markdown("---")
+    with st.expander("⚙️ Settings", expanded=False):
+        # Model settings
+        st.subheader("Model Settings")
+        symptom_model = st.selectbox(
+            "Symptom Extraction Model",
+            ["dmis-lab/biobert-v1.1"],
+            index=0,
+            disabled=st.session_state.loaded_models  # Disable after models are loaded
+        )
+        
+        risk_model = st.selectbox(
+            "Risk Classification Model",
+            ["microsoft/BiomedNLP-PubMedBERT-base-uncased-abstract"],
+            index=0,
+            disabled=st.session_state.loaded_models  # Disable after models are loaded
+        )
+        
+        # 查找可用的t5模型
+        available_t5_model = find_fine_tuned_model()
+        recommendation_model_options = []
+        
+        # 总是添加基础模型
+        recommendation_model_options.append("t5-small (base model)")
+        
+        # 如果找到了fine-tuned模型，添加到选项中
+        if available_t5_model != "t5-small":
+            recommendation_model_options.insert(0, f"{available_t5_model} (fine-tuned)")
+        
+        recommendation_model_label = st.selectbox(
+            "Recommendation Model",
+            recommendation_model_options,
+            index=0,
+            disabled=st.session_state.loaded_models  # Disable after models are loaded
+        )
+        
+        # 提取实际的模型路径
+        if "(fine-tuned)" in recommendation_model_label:
+            recommendation_model = available_t5_model
+        else:
+            recommendation_model = "t5-small"
+        
+        # Device selection
+        device = st.radio(
+            "Compute Device",
+            ["CPU", "GPU (if available)"],
+            index=1 if torch.cuda.is_available() else 0,
+            disabled=st.session_state.loaded_models  # Disable after models are loaded
+        )
+        device = "cuda" if device == "GPU (if available)" and torch.cuda.is_available() else "cpu"
+        
+        if st.session_state.loaded_models:
+            st.info("注意：设置已锁定，因为模型已加载。要更改设置，请刷新页面。")
+        
+    # Consultation history section
+    st.markdown("---")
+    st.subheader("📋 Consultation History")
+    
+    # Load consultation history
+    if st.button("Refresh History"):
+        st.session_state.consultation_history = load_consultation_history()
+        st.success("History refreshed!")
+    
+    # If history is not already loaded, load it
+    if not st.session_state.consultation_history:
+        st.session_state.consultation_history = load_consultation_history()
+    
+    # Display history items
+    if not st.session_state.consultation_history:
+        st.info("No previous consultations found.")
+    else:
+        for i, consultation in enumerate(st.session_state.consultation_history[:10]):  # Show only the 10 most recent
+            timestamp = pd.to_datetime(consultation.get("timestamp", "")).strftime("%Y-%m-%d %H:%M")
+            risk_level = consultation.get("risk", {}).get("risk_level", "Unknown")
+            risk_color = RISK_COLORS.get(risk_level, "#6c757d")
+            
+            # Create a clickable history item
+            history_item = f"""
+            <div class='history-item' onclick=''>
+                <strong>Patient Input:</strong> {consultation.get('input_text', '')[:50]}...<br>
+                <strong>Time:</strong> {timestamp}<br>
+                <strong>Risk Level:</strong> <span style='color:{risk_color};'>{risk_level}</span>
+            </div>
+            """
+            clicked = st.markdown(history_item, unsafe_allow_html=True)
+            
+            # If clicked, set this consultation as the current result
+            if clicked:
+                st.session_state.current_result = consultation
+
+# Main app layout
+st.markdown("<h1 class='main-header'>AI-Powered Medical Consultation</h1>", unsafe_allow_html=True)
+
+# Introduction row
+col1, col2 = st.columns([2, 1])
+with col1:
+    st.markdown("""
+    <div class="card">
+        <h2 class="card-header">How it Works</h2>
+        <p>This AI-powered medical consultation system helps you understand your symptoms and provides guidance on next steps.</p>
+        <p><strong>Simply describe your symptoms</strong> in natural language and the system will:</p>
+        <ol>
+            <li>Extract key symptoms and duration information</li>
+            <li>Assess your risk level</li>
+            <li>Generate personalized medical recommendations</li>
+        </ol>
+        <p><em>Note: This system is for informational purposes only and does not replace professional medical advice.</em></p>
+    </div>
+    """, unsafe_allow_html=True)
+
+with col2:
+    st.markdown("""
+    <div class="card">
+        <h2 class="card-header">Example Inputs</h2>
+        <ul>
+            <li>"I've been experiencing severe headaches and dizziness for about 2 weeks. Sometimes I also feel nauseous."</li>
+            <li>"My child has had a high fever of 39°C since yesterday and is coughing a lot."</li>
+            <li>"I've noticed a persistent rash on my arm for the past 3 days, it's itchy and slightly swollen."</li>
+        </ul>
+    </div>
+    """, unsafe_allow_html=True)
+
+# 显示当前使用的模型信息
+model_info = f"""
+<div class="card">
+    <h2 class="card-header">当前模型配置</h2>
+    <ul>
+        <li><strong>症状抽取模型:</strong> {symptom_model}</li>
+        <li><strong>风险分类模型:</strong> {risk_model}</li>
+        <li><strong>推荐生成模型:</strong> {recommendation_model} {"(微调模型)" if recommendation_model != "t5-small" else "(基础模型)"}</li>
+        <li><strong>计算设备:</strong> {device.upper()}</li>
+    </ul>
+</div>
+"""
+st.markdown(model_info, unsafe_allow_html=True)
+
+# Load models on first run or when settings change
+@st.cache_resource
+def load_pipeline(_symptom_model, _risk_model, _recommendation_model, _device):
+    return MedicalConsultationPipeline(
+        symptom_model=_symptom_model,
+        risk_model=_risk_model,
+        recommendation_model=_recommendation_model,
+        device=_device
+    )
+
+# Only load models if they haven't been loaded yet
+if not st.session_state.loaded_models:
+    try:
+        with st.spinner("Loading AI models... This may take a minute..."):
+            pipeline = load_pipeline(symptom_model, risk_model, recommendation_model, device)
+            st.session_state.pipeline = pipeline
+            st.session_state.loaded_models = True
+            st.success("✅ Models loaded successfully!")
+    except Exception as e:
+        st.error(f"Error loading models: {str(e)}")
+else:
+    pipeline = st.session_state.pipeline
+
+# Input section
+st.markdown("<h2 class='subheader'>Describe Your Symptoms</h2>", unsafe_allow_html=True)
+
+# Text input for patient description
+patient_input = st.text_area(
+    "Please describe your symptoms, including when they started and any other relevant information:",
+    height=150,
+    placeholder="Example: I've been experiencing severe headaches and dizziness for about 2 weeks. Sometimes I also feel nauseous."
+)
+
+# Process button
+col1, col2, col3 = st.columns([1, 1, 1])
+with col2:
+    process_button = st.button("Analyze Symptoms", type="primary", use_container_width=True)
+
+# Handle processing
+if process_button and patient_input and not st.session_state.is_processing:
+    st.session_state.is_processing = True
+    
+    # Process the input
+    with st.spinner("Analyzing your symptoms..."):
+        try:
+            # Process through pipeline
+            start_time = time.time()
+            result = pipeline.process(patient_input)
+            elapsed_time = time.time() - start_time
+            
+            # Save result to session state
+            st.session_state.current_result = result
+            
+            # Save consultation to history
+            save_consultation(result)
+            
+            # Success message
+            st.success(f"Analysis completed in {elapsed_time:.2f} seconds!")
+        except Exception as e:
+            st.error(f"Error processing your input: {str(e)}")
+    
+    st.session_state.is_processing = False
+
+# Results section - show if there's a current result
+if st.session_state.current_result:
+    result = st.session_state.current_result
+    
+    st.markdown("<h2 class='subheader'>Consultation Results</h2>", unsafe_allow_html=True)
+    
+    # Create tabs for different sections of the results
+    tabs = st.tabs(["Overview", "Symptoms Analysis", "Risk Assessment", "Recommendations"])
+    
+    # Overview tab - summary of all results
+    with tabs[0]:
+        col1, col2 = st.columns([3, 2])
+        
+        with col1:
+            st.markdown("""
+            <div class="card">
+                <h3 class="card-header">Patient Description</h3>
+            """, unsafe_allow_html=True)
+            
+            # Highlight symptoms and duration in the text
+            highlighted_text = highlight_text_with_entities(
+                result.get("input_text", ""),
+                result.get("extraction", {}).get("symptoms", [])
+            )
+            st.markdown(f"<p>{highlighted_text}</p>", unsafe_allow_html=True)
+            
+            st.markdown("</div>", unsafe_allow_html=True)
+            
+            # Recommendations card
+            st.markdown("""
+            <div class="card">
+                <h3 class="card-header">Medical Recommendations</h3>
+                <div class="recommendation-container">
+            """, unsafe_allow_html=True)
+            
+            recommendation = result.get("recommendation", "No recommendations available.")
+            st.markdown(f"<p>{recommendation}</p>", unsafe_allow_html=True)
+            
+            st.markdown("""
+                </div>
+                <p><em>Note: This is AI-generated guidance and should not replace professional medical advice.</em></p>
+            </div>
+            """, unsafe_allow_html=True)
+        
+        with col2:
+            # Risk level card
+            risk_level = result.get("risk", {}).get("risk_level", "Unknown")
+            confidence = result.get("risk", {}).get("confidence", 0.0)
+            
+            st.markdown(f"""
+            <div class="card">
+                <h3 class="card-header">Risk Assessment</h3>
+                <div style="text-align: center;">
+                    <span class="risk-{risk_level.lower()}" style="font-size: 1.8rem;">{risk_level}</span>
+                    <p>Confidence: {confidence:.1%}</p>
+                </div>
+            """, unsafe_allow_html=True)
+            
+            # Add risk gauge
+            risk_gauge = create_risk_gauge(risk_level, confidence)
+            st.plotly_chart(risk_gauge, use_container_width=True, key="overview_risk_gauge")
+            
+            st.markdown("</div>", unsafe_allow_html=True)
+            
+            # Extracted symptoms summary
+            st.markdown("""
+            <div class="card">
+                <h3 class="card-header">Key Findings</h3>
+            """, unsafe_allow_html=True)
+            
+            symptoms = result.get("extraction", {}).get("symptoms", [])
+            duration = result.get("extraction", {}).get("duration", [])
+            
+            if symptoms:
+                st.markdown("<strong>Identified Symptoms:</strong>", unsafe_allow_html=True)
+                for symptom in symptoms:
+                    st.markdown(f"• {symptom['text']} ({symptom['score']:.1%} confidence)", unsafe_allow_html=True)
+            else:
+                st.info("No specific symptoms identified")
+            
+            st.markdown("<br><strong>Duration Information:</strong>", unsafe_allow_html=True)
+            st.markdown(f"<p>{format_duration(duration)}</p>", unsafe_allow_html=True)
+            
+            st.markdown("</div>", unsafe_allow_html=True)
+    
+    # Symptoms Analysis tab
+    with tabs[1]:
+        st.markdown("""
+        <div class="card">
+            <h3 class="card-header">Detailed Symptom Analysis</h3>
+        """, unsafe_allow_html=True)
+        
+        symptoms = result.get("extraction", {}).get("symptoms", [])
+        
+        if symptoms:
+            # Create a DataFrame for symptoms
+            symptom_df = pd.DataFrame([
+                {
+                    "Symptom": s["text"],
+                    "Confidence": s["score"], 
+                    "Start Position": s["start"],
+                    "End Position": s["end"]
+                } for s in symptoms
+            ])
+            
+            # Sort by confidence
+            symptom_df = symptom_df.sort_values("Confidence", ascending=False)
+            
+            # Display DataFrame
+            st.dataframe(symptom_df, use_container_width=True)
+            
+            # Bar chart of symptoms by confidence
+            if len(symptoms) > 1:
+                st.markdown("<h4>Symptom Confidence Scores</h4>", unsafe_allow_html=True)
+                chart_data = symptom_df[["Symptom", "Confidence"]].set_index("Symptom")
+                st.bar_chart(chart_data, use_container_width=True)
+        else:
+            st.info("No specific symptoms were detected in the input text.")
+        
+        st.markdown("</div>", unsafe_allow_html=True)
+        
+        # Duration information card
+        st.markdown("""
+        <div class="card">
+            <h3 class="card-header">Duration Analysis</h3>
+        """, unsafe_allow_html=True)
+        
+        duration = result.get("extraction", {}).get("duration", [])
+        
+        if duration:
+            # Create a DataFrame for duration information
+            duration_df = pd.DataFrame([
+                {
+                    "Duration": d["text"],
+                    "Start Position": d["start"],
+                    "End Position": d["end"]
+                } for d in duration
+            ])
+            
+            # Display DataFrame
+            st.dataframe(duration_df, use_container_width=True)
+            
+            # Highlight duration in text
+            st.markdown("<h4>Original Text with Duration Highlighted</h4>", unsafe_allow_html=True)
+            
+            # Highlight duration in a different color
+            duration_text = result.get("input_text", "")
+            sorted_duration = sorted(duration, key=lambda x: x['start'], reverse=True)
+            
+            for d in sorted_duration:
+                start = d['start']
+                end = d['end']
+                highlight = f"<span class='duration-highlight'>{duration_text[start:end]}</span>"
+                duration_text = duration_text[:start] + highlight + duration_text[end:]
+            
+            st.markdown(f"<p>{duration_text}</p>", unsafe_allow_html=True)
+        else:
+            st.info("No specific duration information was detected in the input text.")
+        
+        st.markdown("</div>", unsafe_allow_html=True)
+    
+    # Risk Assessment tab
+    with tabs[2]:
+        st.markdown("""
+        <div class="card">
+            <h3 class="card-header">Risk Level Assessment</h3>
+        """, unsafe_allow_html=True)
+        
+        risk_data = result.get("risk", {})
+        risk_level = risk_data.get("risk_level", "Unknown")
+        confidence = risk_data.get("confidence", 0.0)
+        probabilities = risk_data.get("all_probabilities", {})
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Display risk gauge
+            risk_gauge = create_risk_gauge(risk_level, confidence)
+            st.plotly_chart(risk_gauge, use_container_width=True, key="risk_assessment_gauge")
+        
+        with col2:
+            # Display probability distribution
+            prob_chart = create_risk_probability_chart(probabilities)
+            st.plotly_chart(prob_chart, use_container_width=True, key="risk_probability_chart")
+        
+        # Risk level descriptions
+        st.markdown("<h4>Risk Levels Explained</h4>", unsafe_allow_html=True)
+        
+        risk_descriptions = {
+            "Low": """
+                <div style="border-left: 3px solid #7FD8BE; padding-left: 10px; margin: 10px 0;">
+                    <strong style="color: #7FD8BE;">Low Risk</strong>: Your symptoms suggest a condition that is likely non-urgent. 
+                    While it's good to stay vigilant, these types of conditions typically don't require immediate medical attention 
+                    and can often be managed with self-care or a routine appointment within the next few days or weeks.
+                </div>
+            """,
+            
+            "Medium": """
+                <div style="border-left: 3px solid #FFC857; padding-left: 10px; margin: 10px 0;">
+                    <strong style="color: #FFC857;">Medium Risk</strong>: Your symptoms indicate a condition that may need medical attention 
+                    soon, but may not be an emergency. Consider scheduling an appointment with your primary care provider within 24-48 hours, 
+                    or visit an urgent care facility if your symptoms worsen or if you cannot schedule a timely appointment.
+                </div>
+            """,
+            
+            "High": """
+                <div style="border-left: 3px solid #E84855; padding-left: 10px; margin: 10px 0;">
+                    <strong style="color: #E84855;">High Risk</strong>: Your symptoms suggest a potentially serious condition that requires 
+                    prompt medical attention. Consider seeking emergency care or calling emergency services if symptoms are severe or rapidly 
+                    worsening, especially if they include difficulty breathing, severe pain, or altered consciousness.
+                </div>
+            """
+        }
+        
+        # Display the description for the current risk level first
+        if risk_level in risk_descriptions:
+            st.markdown(risk_descriptions[risk_level], unsafe_allow_html=True)
+        
+        # Then display the others
+        for level, desc in risk_descriptions.items():
+            if level != risk_level:
+                st.markdown(desc, unsafe_allow_html=True)
+        
+        st.markdown("</div>", unsafe_allow_html=True)
+        
+        # Disclaimer
+        st.warning("""
+            **Important Disclaimer**: This risk assessment is based on AI analysis and should be used as a guidance only. 
+            It is not a definitive medical diagnosis. Always consult with a healthcare professional for proper evaluation, 
+            especially if you experience severe symptoms, symptoms that persist or worsen, or if you're unsure about your condition.
+        """)
+    
+    # Recommendations tab
+    with tabs[3]:
+        st.markdown("""
+        <div class="card">
+            <h3 class="card-header">Detailed Recommendations</h3>
+        """, unsafe_allow_html=True)
+        
+        recommendation = result.get("recommendation", "No recommendations available.")
+        
+        # Split recommendation into paragraphs for better readability
+        recommendation_parts = recommendation.split('. ')
+        formatted_recommendation = ""
+        
+        current_paragraph = []
+        for part in recommendation_parts:
+            current_paragraph.append(part)
+            
+            # Start a new paragraph every 2-3 sentences
+            if len(current_paragraph) >= 2 and part.endswith('.'):
+                formatted_recommendation += '. '.join(current_paragraph) + ".<br><br>"
+                current_paragraph = []
+        
+        # Add any remaining parts
+        if current_paragraph:
+            formatted_recommendation += '. '.join(current_paragraph)
+        
+        st.markdown(f"<p>{formatted_recommendation}</p>", unsafe_allow_html=True)
+        
+        st.markdown("</div>", unsafe_allow_html=True)
+        
+        # Department suggestion based on symptoms
+        st.markdown("""
+        <div class="card">
+            <h3 class="card-header">Suggested Medical Departments</h3>
+        """, unsafe_allow_html=True)
+        
+        # 使用模型生成的科室建议而不是规则基础的建议
+        departments = result.get("structured_recommendation", {}).get("departments", [])
+        if not departments:
+            departments = ["General Medicine / Primary Care"]
+        
+        # Display departments
+        for dept in departments:
+            st.markdown(f"• **{dept}**", unsafe_allow_html=True)
+        
+        st.markdown("<br><em>Note: Department suggestions are based on your symptoms and risk level. Consult with a healthcare provider for proper referral.</em>", unsafe_allow_html=True)
+        
+        st.markdown("</div>", unsafe_allow_html=True)
+        
+        # Self-care suggestions
+        st.markdown("""
+        <div class="card">
+            <h3 class="card-header">Self-Care Suggestions</h3>
+        """, unsafe_allow_html=True)
+        
+        # 使用模型生成的自我护理建议
+        self_care_tips = result.get("structured_recommendation", {}).get("self_care", [])
+        
+        if self_care_tips:
+            st.markdown("<ul>", unsafe_allow_html=True)
+            for tip in self_care_tips:
+                st.markdown(f"<li>{tip}</li>", unsafe_allow_html=True)
+            st.markdown("</ul>", unsafe_allow_html=True)
+        else:
+            # 如果没有获取到模型生成的自我护理建议，则显示默认信息
+            risk_level = result.get("risk", {}).get("risk_level", "Medium")
+            if risk_level == "Low":
+                st.markdown("""
+                    <p>While waiting for your symptoms to improve:</p>
+                    <ul>
+                        <li>Ensure you're getting adequate rest</li>
+                        <li>Stay hydrated by drinking plenty of water</li>
+                        <li>Monitor your symptoms and note any changes</li>
+                        <li>Consider over-the-counter medications appropriate for your symptoms</li>
+                        <li>Maintain a balanced diet to support your immune system</li>
+                    </ul>
+                """, unsafe_allow_html=True)
+            elif risk_level == "Medium":
+                st.markdown("""
+                    <p>While arranging medical care:</p>
+                    <ul>
+                        <li>Rest and avoid strenuous activities</li>
+                        <li>Stay hydrated and maintain proper nutrition</li>
+                        <li>Take your temperature and other vital signs if possible</li>
+                        <li>Write down any changes in symptoms and when they occur</li>
+                        <li>Have someone stay with you if your symptoms are concerning</li>
+                    </ul>
+                """, unsafe_allow_html=True)
+            else:  # High risk
+                st.markdown("""
+                    <p>While seeking emergency care:</p>
+                    <ul>
+                        <li>Don't wait - seek medical attention immediately</li>
+                        <li>Have someone drive you to the emergency room if safe to do so</li>
+                        <li>Call emergency services if symptoms are severe</li>
+                        <li>Bring a list of your current medications if possible</li>
+                        <li>Follow any first aid protocols appropriate for your symptoms</li>
+                    </ul>
+                """, unsafe_allow_html=True)
+        
+        st.markdown("</div>", unsafe_allow_html=True)
+
+# Footer
+st.markdown("""
+<div class="footer">
+    <p>AI Medical Consultation System | Created with Streamlit | Not a substitute for professional medical advice</p>
+    <p>Powered by: dmis-lab/biobert-v1.1, microsoft/BiomedNLP-PubMedBERT-base-uncased-abstract, and fine-tuned T5-small</p>
+</div>
+""", unsafe_allow_html=True) 

models.py

@@ -0,0 +1,549 @@
+import torch
+import numpy as np
+from transformers import (
+    AutoTokenizer, 
+    AutoModelForTokenClassification,
+    AutoModelForSequenceClassification,
+    AutoModelForSeq2SeqLM,
+    pipeline
+)
+import re
+import os
+import json
+from typing import Dict, List, Tuple, Any
+
+class SymptomExtractor:
+    """Model for extracting symptoms from patient descriptions using BioBERT."""
+    
+    def __init__(self, model_name="dmis-lab/biobert-v1.1", device=None):
+        self.device = device if device else ("cuda" if torch.cuda.is_available() else "cpu")
+        print(f"Loading Symptom Extractor model on {self.device}...")
+        
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModelForTokenClassification.from_pretrained(model_name).to(self.device)
+        self.nlp = pipeline("ner", model=self.model, tokenizer=self.tokenizer, device=0 if self.device == "cuda" else -1)
+        
+        print("Symptom Extractor model loaded successfully.")
+    
+    def extract_symptoms(self, text: str) -> Dict[str, Any]:
+        """Extract symptoms from the input text."""
+        results = self.nlp(text)
+        
+        # Process the NER results to group related tokens
+        symptoms = []
+        current_symptom = None
+        
+        for entity in results:
+            if entity["entity"].startswith("B-"):  # Beginning of a symptom
+                if current_symptom:
+                    symptoms.append(current_symptom)
+                current_symptom = {
+                    "text": entity["word"],
+                    "start": entity["start"],
+                    "end": entity["end"],
+                    "score": entity["score"]
+                }
+            elif entity["entity"].startswith("I-") and current_symptom:  # Inside a symptom
+                current_symptom["text"] += " " + entity["word"].replace("##", "")
+                current_symptom["end"] = entity["end"]
+                current_symptom["score"] = (current_symptom["score"] + entity["score"]) / 2
+        
+        if current_symptom:
+            symptoms.append(current_symptom)
+        
+        # Extract duration information
+        duration_patterns = [
+            r"(\d+)\s*(day|days|week|weeks|month|months|year|years)",
+            r"since\s+(\w+)",
+            r"for\s+(\w+)"
+        ]
+        
+        duration_info = []
+        for pattern in duration_patterns:
+            matches = re.finditer(pattern, text, re.IGNORECASE)
+            for match in matches:
+                duration_info.append({
+                    "text": match.group(0),
+                    "start": match.start(),
+                    "end": match.end()
+                })
+        
+        return {
+            "symptoms": symptoms,
+            "duration": duration_info
+        }
+
+
+class RiskClassifier:
+    """Model for classifying patient risk level using PubMedBERT."""
+    
+    def __init__(self, model_name="microsoft/BiomedNLP-PubMedBERT-base-uncased-abstract", device=None):
+        self.device = device if device else ("cuda" if torch.cuda.is_available() else "cpu")
+        print(f"Loading Risk Classifier model on {self.device}...")
+        
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModelForSequenceClassification.from_pretrained(
+            model_name, 
+            num_labels=3  # Low, Medium, High
+        ).to(self.device)
+        
+        self.id2label = {0: "Low", 1: "Medium", 2: "High"}
+        print("Risk Classifier model loaded successfully.")
+    
+    def classify_risk(self, text: str) -> Dict[str, Any]:
+        """Classify the risk level based on the input text."""
+        inputs = self.tokenizer(
+            text, 
+            return_tensors="pt",
+            padding=True,
+            truncation=True,
+            max_length=512
+        ).to(self.device)
+        
+        with torch.no_grad():
+            outputs = self.model(**inputs)
+        
+        logits = outputs.logits
+        probabilities = torch.softmax(logits, dim=1)[0].cpu().numpy()
+        model_prediction = torch.argmax(logits, dim=1).item()
+        
+        # 由于模型没有经过微调，我们添加基于规则的后处理来调整风险级别
+        # 检查文本中是否存在高风险关键词
+        high_risk_keywords = [
+            "severe", "extreme", "intense", "unbearable", "emergency",
+            "chest pain", "difficulty breathing", "can't breathe", 
+            "losing consciousness", "fainted", "seizure", "stroke", "heart attack",
+            "allergic reaction", "bleeding heavily", "blood", "poisoning",
+            "overdose", "suicide", "self-harm", "hallucinations"
+        ]
+        
+        medium_risk_keywords = [
+            "worsening", "spreading", "persistent", "chronic", "recurring",
+            "infection", "fever", "swelling", "rash", "pain", "vomiting",
+            "diarrhea", "dizzy", "headache", "concerning", "worried",
+            "weeks", "days", "increasing", "progressing"
+        ]
+        
+        low_risk_keywords = [
+            "mild", "slight", "minor", "occasional", "intermittent",
+            "improving", "better", "sometimes", "rarely", "manageable"
+        ]
+        
+        text_lower = text.lower()
+        
+        # 计算匹配的关键词数量
+        high_risk_matches = sum(keyword in text_lower for keyword in high_risk_keywords)
+        medium_risk_matches = sum(keyword in text_lower for keyword in medium_risk_keywords)
+        low_risk_matches = sum(keyword in text_lower for keyword in low_risk_keywords)
+        
+        # 根据关键词匹配调整风险预测
+        adjusted_prediction = model_prediction
+        if high_risk_matches >= 2:
+            adjusted_prediction = 2  # High risk
+        elif high_risk_matches == 1 and medium_risk_matches >= 2:
+            adjusted_prediction = 2  # High risk
+        elif medium_risk_matches >= 3:
+            adjusted_prediction = 1  # Medium risk
+        elif medium_risk_matches >= 1 and low_risk_matches <= 1:
+            adjusted_prediction = 1  # Medium risk
+        elif low_risk_matches >= 2 and high_risk_matches == 0:
+            adjusted_prediction = 0  # Low risk
+        
+        # 如果文本很长（详细描述），可能表明情况更复杂，风险更高
+        if len(text.split()) > 40 and adjusted_prediction == 0:
+            adjusted_prediction = 1  # 升级到Medium风险
+        
+        # 对调整后的概率进行修正
+        adjusted_probabilities = probabilities.copy()
+        # 增强对应风险级别的概率
+        adjusted_probabilities[adjusted_prediction] = max(0.6, adjusted_probabilities[adjusted_prediction])
+        # 规范化概率使其总和为1
+        adjusted_probabilities = adjusted_probabilities / adjusted_probabilities.sum()
+        
+        return {
+            "risk_level": self.id2label[adjusted_prediction],
+            "confidence": float(adjusted_probabilities[adjusted_prediction]),
+            "all_probabilities": {
+                self.id2label[i]: float(prob) 
+                for i, prob in enumerate(adjusted_probabilities)
+            },
+            "original_prediction": self.id2label[model_prediction]
+        }
+
+
+class RecommendationGenerator:
+    """Model for generating medical recommendations using fine-tuned t5-small."""
+    
+    def __init__(self, model_path="t5-small", device=None):
+        self.device = device if device else ("cuda" if torch.cuda.is_available() else "cpu")
+        print(f"Loading Recommendation Generator model on {self.device}...")
+        
+        # 检查常见的微调模型路径
+        possible_local_paths = [
+            "./finetuned_t5-small",  # 添加用户指定的微调模型路径
+            "./t5-small-medical-recommendation",
+            "./models/t5-small-medical-recommendation",
+            "./fine_tuned_models/t5-small",
+            "./output",
+            "./fine_tuning_output"
+        ]
+        
+        # 检查是否为路径或模型标识符
+        model_exists = False
+        for path in possible_local_paths:
+            if os.path.exists(path):
+                model_path = path
+                model_exists = True
+                print(f"Found fine-tuned model at: {model_path}")
+                break
+        
+        if not model_exists and model_path == "t5-small-medical-recommendation":
+            print("Fine-tuned model not found locally. Falling back to base t5-small...")
+            model_path = "t5-small"
+        
+        try:
+            self.tokenizer = AutoTokenizer.from_pretrained(model_path)
+            self.model = AutoModelForSeq2SeqLM.from_pretrained(model_path).to(self.device)
+            print(f"Recommendation Generator model '{model_path}' loaded successfully.")
+        except Exception as e:
+            print(f"Error loading model from {model_path}: {str(e)}")
+            print("Falling back to base t5-small model...")
+            self.tokenizer = AutoTokenizer.from_pretrained("t5-small")
+            self.model = AutoModelForSeq2SeqLM.from_pretrained("t5-small").to(self.device)
+            print("Base t5-small model loaded successfully as fallback.")
+            
+        # 科室映射 - 症状关键词到科室的映射
+        self.symptom_to_department = {
+            "headache": "Neurology",
+            "dizziness": "Neurology",
+            "confusion": "Neurology",
+            "memory": "Neurology",
+            "numbness": "Neurology",
+            "tingling": "Neurology",
+            "seizure": "Neurology",
+            "nerve": "Neurology",
+            
+            "chest pain": "Cardiology",
+            "heart": "Cardiology", 
+            "palpitation": "Cardiology",
+            "arrhythmia": "Cardiology",
+            "high blood pressure": "Cardiology",
+            "hypertension": "Cardiology",
+            "heart attack": "Cardiology",
+            "cardiovascular": "Cardiology",
+            
+            "cough": "Pulmonology",
+            "breathing": "Pulmonology",
+            "shortness": "Pulmonology",
+            "lung": "Pulmonology",
+            "respiratory": "Pulmonology",
+            "asthma": "Pulmonology",
+            "pneumonia": "Pulmonology",
+            "copd": "Pulmonology",
+            
+            "stomach": "Gastroenterology",
+            "abdomen": "Gastroenterology",
+            "nausea": "Gastroenterology",
+            "vomit": "Gastroenterology",
+            "diarrhea": "Gastroenterology",
+            "constipation": "Gastroenterology",
+            "heartburn": "Gastroenterology",
+            "liver": "Gastroenterology",
+            "digestive": "Gastroenterology",
+            
+            "joint": "Orthopedics",
+            "bone": "Orthopedics",
+            "muscle": "Orthopedics",
+            "pain": "Orthopedics",
+            "back": "Orthopedics",
+            "arthritis": "Orthopedics",
+            "fracture": "Orthopedics",
+            "sprain": "Orthopedics",
+            
+            "rash": "Dermatology",
+            "skin": "Dermatology",
+            "itching": "Dermatology",
+            "itch": "Dermatology",
+            "acne": "Dermatology",
+            "eczema": "Dermatology",
+            "psoriasis": "Dermatology",
+            
+            "fever": "General Medicine / Primary Care",
+            "infection": "General Medicine / Primary Care",
+            "sore throat": "General Medicine / Primary Care",
+            "flu": "General Medicine / Primary Care",
+            "cold": "General Medicine / Primary Care",
+            "fatigue": "General Medicine / Primary Care",
+            
+            "pregnancy": "Obstetrics / Gynecology",
+            "menstruation": "Obstetrics / Gynecology",
+            "period": "Obstetrics / Gynecology",
+            "vaginal": "Obstetrics / Gynecology",
+            "menopause": "Obstetrics / Gynecology",
+            
+            "depression": "Psychiatry",
+            "anxiety": "Psychiatry",
+            "mood": "Psychiatry",
+            "stress": "Psychiatry",
+            "sleep": "Psychiatry",
+            "insomnia": "Psychiatry",
+            "mental": "Psychiatry",
+            
+            "ear": "Otolaryngology (ENT)",
+            "nose": "Otolaryngology (ENT)",
+            "throat": "Otolaryngology (ENT)",
+            "hearing": "Otolaryngology (ENT)",
+            "sinus": "Otolaryngology (ENT)",
+            
+            "eye": "Ophthalmology",
+            "vision": "Ophthalmology",
+            "blindness": "Ophthalmology",
+            "blurry": "Ophthalmology",
+            
+            "urination": "Urology",
+            "kidney": "Urology",
+            "bladder": "Urology",
+            "urine": "Urology",
+            "prostate": "Urology"
+        }
+        
+        # 自我护理建议
+        self.self_care_by_risk = {
+            "Low": [
+                "Ensure you're getting adequate rest",
+                "Stay hydrated by drinking plenty of water",
+                "Monitor your symptoms and note any changes",
+                "Consider over-the-counter medications appropriate for your symptoms",
+                "Maintain a balanced diet to support your immune system",
+                "Try gentle exercises if appropriate for your condition",
+                "Avoid activities that worsen your symptoms",
+                "Keep track of any patterns in your symptoms"
+            ],
+            "Medium": [
+                "Rest and avoid strenuous activities",
+                "Stay hydrated and maintain proper nutrition",
+                "Take your temperature and other vital signs if possible",
+                "Write down any changes in symptoms and when they occur",
+                "Have someone stay with you if your symptoms are concerning",
+                "Prepare a list of your symptoms and medications for your doctor",
+                "Avoid self-medicating beyond basic over-the-counter remedies",
+                "Consider arranging transportation to your medical appointment"
+            ],
+            "High": [
+                "Don't wait - seek medical attention immediately",
+                "Have someone drive you to the emergency room if safe to do so",
+                "Call emergency services if symptoms are severe",
+                "Bring a list of your current medications if possible",
+                "Follow any first aid protocols appropriate for your symptoms",
+                "Don't eat or drink anything if you might need surgery",
+                "Take prescribed emergency medications if applicable (like an inhaler for asthma)",
+                "Try to remain calm and focused on getting help"
+            ]
+        }
+    
+    def _extract_departments_from_symptoms(self, symptoms_text: str) -> List[str]:
+        """
+        从症状描述中提取可能的相关科室
+        
+        Args:
+            symptoms_text: 症状描述文本
+        
+        Returns:
+            科室名称列表
+        """
+        departments = set()
+        symptoms_lower = symptoms_text.lower()
+        
+        # 通过关键词匹配寻找相关科室
+        for keyword, department in self.symptom_to_department.items():
+            if keyword in symptoms_lower:
+                departments.add(department)
+        
+        # 如果没有找到匹配的科室，返回常规医疗科室
+        if not departments:
+            departments.add("General Medicine / Primary Care")
+            
+        return list(departments)
+    
+    def _get_self_care_suggestions(self, risk_level: str) -> List[str]:
+        """
+        根据风险级别获取自我护理建议
+        
+        Args:
+            risk_level: 风险级别 (Low, Medium, High)
+        
+        Returns:
+            自我护理建议列表
+        """
+        # 确保风险级别有效
+        if risk_level not in self.self_care_by_risk:
+            risk_level = "Medium"  # 默认返回中等风险的建议
+            
+        # 返回为该风险级别准备的建议
+        suggestions = self.self_care_by_risk[risk_level]
+        
+        # 随机选择5项建议，避免每次返回完全相同的内容
+        import random
+        if len(suggestions) > 5:
+            selected = random.sample(suggestions, 5)
+        else:
+            selected = suggestions
+            
+        return selected
+    
+    def _format_structured_recommendation(self, medical_advice: str, departments: List[str], self_care: List[str], risk_level: str) -> str:
+        """
+        格式化结构化建议为文本格式
+        
+        Args:
+            medical_advice: 主要医疗建议
+            departments: 建议科室列表
+            self_care: 自我护理建议列表
+            risk_level: 风险级别
+        
+        Returns:
+            格式化后的完整建议文本
+        """
+        # 初始化建议文本
+        recommendation = ""
+        
+        # 添加主要医疗建议
+        recommendation += medical_advice.strip() + "\n\n"
+        
+        # 添加建议科室部分
+        recommendation += f"RECOMMENDED DEPARTMENTS: Based on your symptoms, consider consulting the following departments: {', '.join(departments)}.\n\n"
+        
+        # 添加自我护理部分
+        recommendation += f"SELF-CARE SUGGESTIONS: While {risk_level.lower()} risk level requires {'immediate attention' if risk_level == 'High' else 'medical care soon' if risk_level == 'Medium' else 'monitoring'}, you can also:\n"
+        for suggestion in self_care:
+            recommendation += f"- {suggestion}\n"
+            
+        return recommendation
+    
+    def generate_recommendation(self, 
+                              symptoms: str, 
+                              risk_level: str,
+                              max_length: int = 150) -> Dict[str, Any]:
+        """
+        Generate a comprehensive medical recommendation based on symptoms and risk level.
+        
+        Args:
+            symptoms: Symptom description text
+            risk_level: Risk level (Low, Medium, High)
+            max_length: Maximum length for generated text
+            
+        Returns:
+            Dictionary containing structured recommendation including medical advice,
+            department suggestions, and self-care tips
+        """
+        # 创建输入提示
+        input_text = f"Symptoms: {symptoms} Risk: {risk_level}"
+        
+        # 通过模型生成主要医疗建议
+        inputs = self.tokenizer(
+            input_text, 
+            return_tensors="pt",
+            padding=True,
+            truncation=True,
+            max_length=512
+        ).to(self.device)
+        
+        with torch.no_grad():
+            output_ids = self.model.generate(
+                **inputs,
+                max_length=max_length,
+                num_beams=4,
+                early_stopping=True
+            )
+        
+        # 解码生成的医疗建议
+        medical_advice = self.tokenizer.decode(output_ids[0], skip_special_tokens=True)
+        
+        # 从症状提取建议科室
+        departments = self._extract_departments_from_symptoms(symptoms)
+        
+        # 如果是高风险，添加急诊科
+        if risk_level == "High" and "Emergency Medicine" not in departments:
+            departments.insert(0, "Emergency Medicine")
+            
+        # 获取自我护理建议
+        self_care_suggestions = self._get_self_care_suggestions(risk_level)
+        
+        # 创建完整的结构化建议
+        structured_recommendation = {
+            "medical_advice": medical_advice,
+            "departments": departments,
+            "self_care": self_care_suggestions
+        }
+        
+        # 格式化为文本格式的完整建议
+        formatted_text = self._format_structured_recommendation(
+            medical_advice, 
+            departments, 
+            self_care_suggestions,
+            risk_level
+        )
+        
+        return {
+            "text": formatted_text,
+            "structured": structured_recommendation
+        }
+
+
+class MedicalConsultationPipeline:
+    """Complete pipeline for medical consultation."""
+    
+    def __init__(self, 
+                symptom_model="dmis-lab/biobert-v1.1",
+                risk_model="microsoft/BiomedNLP-PubMedBERT-base-uncased-abstract",
+                recommendation_model="t5-small",
+                device=None):
+        
+        self.device = device if device else ("cuda" if torch.cuda.is_available() else "cpu")
+        print(f"Initializing Medical Consultation Pipeline on {self.device}...")
+        
+        self.symptom_extractor = SymptomExtractor(model_name=symptom_model, device=self.device)
+        self.risk_classifier = RiskClassifier(model_name=risk_model, device=self.device)
+        self.recommendation_generator = RecommendationGenerator(model_path=recommendation_model, device=self.device)
+        
+        print("Medical Consultation Pipeline initialized successfully.")
+    
+    def process(self, text: str) -> Dict[str, Any]:
+        """Process the patient description through the complete pipeline."""
+        # Step 1: Extract symptoms
+        extraction_results = self.symptom_extractor.extract_symptoms(text)
+        
+        # Step 2: Classify risk
+        risk_results = self.risk_classifier.classify_risk(text)
+        
+        # Create a summary of the symptoms for the recommendation model
+        symptoms_summary = ", ".join([symptom["text"] for symptom in extraction_results["symptoms"]])
+        if not symptoms_summary:
+            symptoms_summary = text  # Use original text if no symptoms found
+        
+        # Step 3: Generate recommendation
+        recommendation_result = self.recommendation_generator.generate_recommendation(
+            symptoms=symptoms_summary,
+            risk_level=risk_results["risk_level"]
+        )
+        
+        return {
+            "extraction": extraction_results,
+            "risk": risk_results,
+            "recommendation": recommendation_result["text"],
+            "structured_recommendation": recommendation_result["structured"],
+            "input_text": text
+        }
+        
+# Example usage
+if __name__ == "__main__":
+    # This is just a test code that won't run in the Streamlit app
+    pipeline = MedicalConsultationPipeline()
+    
+    sample_text = "I've been experiencing severe headaches and dizziness for about 2 weeks. Sometimes I also feel nauseous."
+    
+    result = pipeline.process(sample_text)
+    print("Extracted symptoms:", [s["text"] for s in result["extraction"]["symptoms"]])
+    print("Duration info:", [d["text"] for d in result["extraction"]["duration"]])
+    print("Risk level:", result["risk"]["risk_level"], f"(Confidence: {result['risk']['confidence']:.2f})")
+    print("Recommendation:", result["recommendation"]) 

requirements.txt

@@ -1,3 +1,12 @@
-altair
-pandas
-streamlit
+streamlit==1.31.0
+torch==2.0.1
+transformers==4.35.0
+pandas==2.0.3
+numpy==1.24.3
+scikit-learn==1.3.0
+matplotlib==3.7.2
+plotly==5.15.0
+nltk==3.8.1
+spacy==3.6.1
+seaborn==0.12.2
+jsonlines==3.1.0 

style.css

@@ -0,0 +1,245 @@
+/* Main style elements */
+@import url('https://fonts.googleapis.com/css2?family=Roboto:wght@100;300;400;500;700&family=Source+Sans+Pro:wght@400;600;700&display=swap');
+
+html, body, [class*="css"] {
+    font-family: 'Source Sans Pro', -apple-system, BlinkMacSystemFont, sans-serif;
+    color: #2C363F;
+}
+
+.main .block-container {
+    padding-top: 2rem;
+    padding-bottom: 2rem;
+}
+
+/* Header styling */
+.main-header {
+    color: #2C393F;
+    font-weight: 600;
+    text-align: center;
+    margin-bottom: 2rem;
+}
+
+.subheader {
+    color: #557A95;
+    font-weight: 500;
+    font-size: 1.2rem;
+    margin-bottom: 1rem;
+}
+
+/* Card elements */
+.card {
+    background-color: #FFFFFF;
+    border-radius: 10px;
+    border: 1px solid #EAEAEA;
+    padding: 1.5rem;
+    margin-bottom: 1rem;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.05);
+    transition: all 0.3s ease;
+}
+
+.card:hover {
+    box-shadow: 0 6px 8px rgba(0, 0, 0, 0.1);
+    transform: translateY(-2px);
+}
+
+.card-header {
+    font-weight: 600;
+    margin-bottom: 0.8rem;
+    color: #557A95;
+    border-bottom: 1px solid #EAEAEA;
+    padding-bottom: 0.5rem;
+}
+
+/* Risk level indicators */
+.risk-low {
+    color: #7FD8BE;
+    font-weight: 600;
+}
+
+.risk-medium {
+    color: #FFC857;
+    font-weight: 600;
+}
+
+.risk-high {
+    color: #E84855;
+    font-weight: 600;
+}
+
+/* Input area */
+.stTextInput > div > div > input {
+    border-radius: 8px;
+    border: 1px solid #CCCCCC;
+    padding: 0.5rem;
+    font-size: 1rem;
+}
+
+.stTextArea > div > div > textarea {
+    border-radius: 8px;
+    border: 1px solid #CCCCCC;
+    padding: 0.8rem;
+    font-size: 1rem;
+    min-height: 150px;
+}
+
+/* Button styling */
+.stButton > button {
+    background-color: #557A95;
+    color: white;
+    border: none;
+    border-radius: 8px;
+    padding: 0.5rem 2rem;
+    font-weight: 600;
+    transition: all 0.3s ease;
+}
+
+.stButton > button:hover {
+    background-color: #395B74;
+    color: white;
+    transform: translateY(-2px);
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+}
+
+.stButton > button:focus {
+    background-color: #395B74;
+    color: white;
+}
+
+/* Symptom highlight styling */
+.symptom-highlight {
+    background-color: rgba(255, 200, 87, 0.3);
+    border-radius: 3px;
+    padding: 0 3px;
+}
+
+/* Duration highlight styling */
+.duration-highlight {
+    background-color: rgba(127, 216, 190, 0.3);
+    border-radius: 3px;
+    padding: 0 3px;
+}
+
+/* Recommendation styling */
+.recommendation-container {
+    background-color: #F8F9FA;
+    border-left: 5px solid #557A95;
+    padding: 1rem;
+    margin: 1rem 0;
+    border-radius: 0 5px 5px 0;
+}
+
+/* History item */
+.history-item {
+    padding: 1rem;
+    margin-bottom: 0.5rem;
+    border-radius: 5px;
+    border: 1px solid #EAEAEA;
+    background-color: #F8F9FA;
+    cursor: pointer;
+    transition: all 0.2s ease;
+}
+
+.history-item:hover {
+    background-color: #E9ECEF;
+}
+
+/* Loading animation */
+.loading-spinner {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    margin: 2rem 0;
+}
+
+/* Custom metric container */
+.metric-container {
+    background-color: white;
+    border-radius: 10px;
+    padding: 1rem;
+    text-align: center;
+    box-shadow: 0 2px 5px rgba(0, 0, 0, 0.05);
+}
+
+.metric-value {
+    font-size: 2.5rem;
+    font-weight: 600;
+    margin: 0.5rem 0;
+}
+
+.metric-label {
+    font-size: 1rem;
+    color: #6c757d;
+}
+
+/* App footer */
+.footer {
+    text-align: center;
+    margin-top: 3rem;
+    padding-top: 1rem;
+    border-top: 1px solid #EAEAEA;
+    color: #6c757d;
+    font-size: 0.8rem;
+}
+
+/* Override Streamlit's default padding in widgets */
+div.stRadio > div {
+    padding-top: 0.5rem;
+    padding-bottom: 0.5rem;
+}
+
+div.stCheckbox > div {
+    padding-top: 0.5rem;
+    padding-bottom: 0.5rem;
+}
+
+/* Tabs styling */
+.stTabs [data-baseweb="tab-list"] {
+    gap: 1rem;
+}
+
+.stTabs [data-baseweb="tab"] {
+    height: 3rem;
+    border-radius: 8px 8px 0 0;
+    padding: 0 1.5rem;
+    background-color: #F8F9FA;
+}
+
+.stTabs [aria-selected="true"] {
+    background-color: white !important;
+    border-bottom: 2px solid #557A95 !important;
+    font-weight: 600;
+}
+
+/* Responsive adjustments */
+@media (max-width: 768px) {
+    .main .block-container {
+        padding-top: 1rem;
+        padding-bottom: 1rem;
+    }
+    
+    .card {
+        padding: 1rem;
+    }
+    
+    .metric-value {
+        font-size: 2rem;
+    }
+}
+
+/* Animation for success message */
+@keyframes fadeInUp {
+    from {
+        opacity: 0;
+        transform: translateY(20px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+.fadeInUp {
+    animation-name: fadeInUp;
+    animation-duration: 0.5s;
+    animation-fill-mode: both;
+} 

utils.py

@@ -0,0 +1,170 @@
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime
+import json
+import os
+from typing import Dict, List, Any
+
+# Constants
+RISK_COLORS = {
+    "Low": "#7FD8BE",     # Soft mint green
+    "Medium": "#FFC857",  # Warm amber
+    "High": "#E84855"     # Bright red
+}
+
+def highlight_text_with_entities(text: str, entities: List[Dict[str, Any]]) -> str:
+    """
+    Format text with HTML to highlight extracted entities.
+    
+    Args:
+        text: Original input text
+        entities: List of entity dictionaries with 'start', 'end', and 'text' keys
+    
+    Returns:
+        HTML formatted string with highlighted entities
+    """
+    if not entities:
+        return text
+    
+    # Sort entities by start position (descending) to avoid index issues when replacing
+    sorted_entities = sorted(entities, key=lambda x: x['start'], reverse=True)
+    
+    result = text
+    for entity in sorted_entities:
+        start = entity['start']
+        end = entity['end']
+        highlight = f"<span style='background-color: rgba(255, 200, 87, 0.3); border-radius: 3px; padding: 0px 3px;'>{text[start:end]}</span>"
+        result = result[:start] + highlight + result[end:]
+    
+    return result
+
+def format_duration(duration_entities: List[Dict[str, Any]]) -> str:
+    """Format duration entities into a readable string."""
+    if not duration_entities:
+        return "No specific duration mentioned"
+    
+    return ", ".join([entity["text"] for entity in duration_entities])
+
+def create_risk_gauge(risk_level: str, confidence: float) -> go.Figure:
+    """Create a gauge chart for risk level visualization."""
+    
+    # Map risk levels to numerical values for the gauge
+    risk_value_map = {"Low": 1, "Medium": 2, "High": 3}
+    risk_value = risk_value_map.get(risk_level, 2)  # Default to Medium if unknown
+    
+    fig = go.Figure(go.Indicator(
+        mode="gauge+number+delta",
+        value=risk_value,
+        domain={'x': [0, 1], 'y': [0, 1]},
+        gauge={
+            'axis': {'range': [0, 3], 'tickvals': [1, 2, 3], 'ticktext': ['Low', 'Medium', 'High']},
+            'bar': {'color': RISK_COLORS[risk_level]},
+            'steps': [
+                {'range': [0, 1.5], 'color': "rgba(127, 216, 190, 0.3)"},
+                {'range': [1.5, 2.5], 'color': "rgba(255, 200, 87, 0.3)"},
+                {'range': [2.5, 3], 'color': "rgba(232, 72, 85, 0.3)"}
+            ],
+            'threshold': {
+                'line': {'color': "white", 'width': 2},
+                'thickness': 0.85,
+                'value': risk_value
+            }
+        },
+        number={'valueformat': '.0f', 'font': {'size': 36}},
+        title={
+            'text': f"Risk Level: {risk_level}",
+            'font': {'size': 24}
+        },
+    ))
+    
+    fig.update_layout(
+        height=250,
+        margin=dict(l=10, r=10, t=50, b=10),
+        paper_bgcolor='white',
+        font={'color': "#2C363F", 'family': "Arial"}
+    )
+    
+    return fig
+
+def create_risk_probability_chart(probabilities: Dict[str, float]) -> go.Figure:
+    """Create a horizontal bar chart for risk probabilities."""
+    labels = list(probabilities.keys())
+    values = list(probabilities.values())
+    colors = [RISK_COLORS[label] for label in labels]
+    
+    fig = go.Figure(go.Bar(
+        x=values,
+        y=labels,
+        orientation='h',
+        marker_color=colors,
+        text=[f"{v:.1%}" for v in values],
+        textposition='auto'
+    ))
+    
+    fig.update_layout(
+        title="Risk Probability Distribution",
+        xaxis_title="Probability",
+        yaxis_title="Risk Level",
+        height=250,
+        margin=dict(l=10, r=10, t=50, b=10),
+        xaxis=dict(range=[0, 1], tickformat=".0%"),
+        paper_bgcolor='white',
+        plot_bgcolor='white',
+        font={'color': "#2C363F", 'family': "Arial"}
+    )
+    
+    return fig
+
+def save_consultation(consultation_data: Dict[str, Any]):
+    """Save consultation data to a JSON file."""
+    # Create history directory if it doesn't exist
+    os.makedirs("consultation_history", exist_ok=True)
+    
+    # Generate a filename with timestamp
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = f"consultation_history/consultation_{timestamp}.json"
+    
+    # Add timestamp to data
+    consultation_data["timestamp"] = datetime.now().isoformat()
+    
+    # Save to file
+    with open(filename, "w") as f:
+        json.dump(consultation_data, f, indent=2)
+    
+    return filename
+
+def load_consultation_history() -> List[Dict[str, Any]]:
+    """Load all saved consultations from the history directory."""
+    history_dir = "consultation_history"
+    if not os.path.exists(history_dir):
+        return []
+    
+    history = []
+    for filename in os.listdir(history_dir):
+        if filename.endswith(".json"):
+            try:
+                with open(os.path.join(history_dir, filename), "r") as f:
+                    consultation = json.load(f)
+                    history.append(consultation)
+            except Exception as e:
+                st.error(f"Error loading {filename}: {str(e)}")
+    
+    # Sort by timestamp (newest first)
+    history.sort(key=lambda x: x.get("timestamp", ""), reverse=True)
+    return history
+
+def init_session_state():
+    """Initialize session state variables."""
+    if "consultation_history" not in st.session_state:
+        st.session_state.consultation_history = []
+    
+    if "current_result" not in st.session_state:
+        st.session_state.current_result = None
+        
+    if "is_processing" not in st.session_state:
+        st.session_state.is_processing = False
+    
+    if "loaded_models" not in st.session_state:
+        st.session_state.loaded_models = False