Modified files for deployment

.gitignore

@@ -0,0 +1,53 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyTorch
+*.pth
+*.pt
+*.bin
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# Environment variables
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Model cache
+.cache/
+huggingface_hub/

README.md

@@ -1,12 +1,62 @@
 ---
-title: Medical Model
-emoji: 💬
-colorFrom: yellow
-colorTo: purple
+title: MedLLaMA2 Medical Chatbot
+emoji: 🏥
+colorFrom: blue
+colorTo: green
 sdk: gradio
-sdk_version: 5.0.1
+sdk_version: 4.44.0
 app_file: app.py
 pinned: false
+license: apache-2.0
 ---
 
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+# MedLLaMA2 Medical Chatbot 🏥
+
+A medical AI assistant powered by MedLLaMA2 (7B parameters) designed to provide helpful medical information and guidance.
+
+## Features
+
+- **Medical-focused responses**: Trained on medical literature and datasets
+- **Safety-first approach**: Always recommends consulting healthcare professionals
+- **Optimized for Hugging Face Spaces**: Uses 4-bit quantization for efficient memory usage
+- **Interactive chat interface**: Built with Gradio for easy interaction
+
+## Usage
+
+1. Type your medical question or concern in the chat interface
+2. Adjust parameters like temperature and max tokens if needed
+3. The model will provide informative responses while emphasizing professional medical consultation
+
+## Important Disclaimer
+
+⚠️ **This chatbot is for educational and informational purposes only.** 
+
+- It should NOT be used as a substitute for professional medical advice
+- Always consult with qualified healthcare professionals for medical concerns
+- In case of medical emergencies, contact emergency services immediately
+
+## Technical Details
+
+- **Model**: MedLLaMA2 7B (or compatible medical language model)
+- **Framework**: Transformers, PyTorch
+- **Interface**: Gradio ChatInterface
+- **Optimization**: 4-bit quantization with BitsAndBytes
+- **Hardware**: CPU Basic (16GB RAM)
+
+## Examples
+
+Try asking questions like:
+- "What are the symptoms of diabetes?"
+- "How can I maintain a healthy heart?"
+- "What should I know about blood pressure?"
+- "Tell me about the importance of regular exercise."
+
+## Development
+
+This space uses:
+- Python 3.10+
+- Transformers library for model loading
+- Gradio for the web interface
+- BitsAndBytes for model quantization
+
+For more information about the underlying technology, see the [Transformers documentation](https://huggingface.co/docs/transformers/index).

api_server.py

@@ -0,0 +1,177 @@
+"""
+API Server for MedLLaMA2 Medical Chatbot
+This file provides REST API endpoints that can be used by external applications
+while the main app.py provides the Gradio interface.
+"""
+
+import os
+import threading
+from flask import Flask, request, jsonify, Response
+from flask_cors import CORS
+import json
+import time
+import re
+
+# Import the model and functions from the main app
+from app import load_model, generate_response, get_model_info
+from config import GENERATION_DEFAULTS
+
+# Initialize Flask app
+app = Flask(__name__)
+CORS(app)  # Enable CORS for all routes
+
+# Initialize model in a separate thread
+def init_model():
+    print("🔄 Loading model in API server...")
+    load_model()
+    print("✅ Model loaded in API server")
+
+# Start model loading
+model_thread = threading.Thread(target=init_model)
+model_thread.start()
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    """Health check endpoint"""
+    return jsonify({
+        'status': 'ok',
+        'model_loaded': get_model_info() != "No model loaded",
+        'model_info': get_model_info(),
+        'timestamp': time.time()
+    })
+
+@app.route('/chat', methods=['POST'])
+def chat_endpoint():
+    """Main chat endpoint for medical questions"""
+    try:
+        data = request.get_json()
+        
+        if not data or 'message' not in data:
+            return jsonify({'error': 'No message provided'}), 400
+        
+        message = data['message'].strip()
+        if not message:
+            return jsonify({'error': 'Empty message'}), 400
+        
+        # Get optional parameters
+        max_tokens = data.get('max_tokens', GENERATION_DEFAULTS['max_new_tokens'])
+        temperature = data.get('temperature', GENERATION_DEFAULTS['temperature'])
+        top_p = data.get('top_p', GENERATION_DEFAULTS['top_p'])
+        
+        # Check for non-medical topics
+        non_medical_patterns = [
+            r'\b(java|javascript|python|c\+\+|c#|programming|coding|computer|software)\b',
+            r'\b(cook|recipe|food recipe|baking)\b',
+            r'\b(math problem|finance|stock market|weather|movie|book|travel)\b'
+        ]
+        
+        is_non_medical = any(re.search(pattern, message, re.IGNORECASE) for pattern in non_medical_patterns)
+        
+        # Medical exceptions
+        medical_exceptions = [
+            r'medical (history|coding|program|software|algorithm)',
+            r'health (history|software|recipe)',
+            r'(food allergy|diet recipe|patient story|medical story)'
+        ]
+        
+        is_medical_exception = any(re.search(pattern, message, re.IGNORECASE) for pattern in medical_exceptions)
+        
+        if is_non_medical and not is_medical_exception:
+            return jsonify({
+                'response': "I'm a medical assistant designed to provide health-related information. I'm not able to help with programming, cooking, or other non-medical topics. If you have any questions about health, medicine, symptoms, or wellness, I'd be happy to assist you! 😊",
+                'timestamp': time.time()
+            })
+        
+        # Generate medical response
+        response = generate_response(
+            message,
+            max_tokens=int(max_tokens),
+            temperature=float(temperature),
+            top_p=float(top_p)
+        )
+        
+        # Return the response
+        return jsonify({
+            'response': response,
+            'timestamp': time.time(),
+            'model_info': get_model_info()
+        })
+        
+    except Exception as e:
+        print(f"Error in chat endpoint: {str(e)}")
+        return jsonify({
+            'error': 'Internal server error',
+            'details': str(e)
+        }), 500
+
+@app.route('/stream', methods=['POST'])
+def stream_chat():
+    """Streaming chat endpoint"""
+    try:
+        data = request.get_json()
+        
+        if not data or 'message' not in data:
+            return jsonify({'error': 'No message provided'}), 400
+        
+        message = data['message'].strip()
+        if not message:
+            return jsonify({'error': 'Empty message'}), 400
+        
+        def generate_stream():
+            try:
+                # Get parameters
+                max_tokens = data.get('max_tokens', GENERATION_DEFAULTS['max_new_tokens'])
+                temperature = data.get('temperature', GENERATION_DEFAULTS['temperature'])
+                top_p = data.get('top_p', GENERATION_DEFAULTS['top_p'])
+                
+                # Generate response in chunks
+                response = generate_response(
+                    message,
+                    max_tokens=int(max_tokens),
+                    temperature=float(temperature),
+                    top_p=float(top_p)
+                )
+                
+                # Stream the response word by word
+                words = response.split()
+                for i, word in enumerate(words):
+                    chunk_data = {
+                        'chunk': word + (' ' if i < len(words) - 1 else ''),
+                        'status': 'streaming'
+                    }
+                    yield f"data: {json.dumps(chunk_data)}\n\n"
+                    time.sleep(0.05)  # Small delay for streaming effect
+                
+                # Send completion signal
+                end_data = {
+                    'complete': True,
+                    'fullResponse': response
+                }
+                yield f"event: end\ndata: {json.dumps(end_data)}\n\n"
+                
+            except Exception as e:
+                error_data = {
+                    'error': 'Stream error',
+                    'details': str(e)
+                }
+                yield f"event: error\ndata: {json.dumps(error_data)}\n\n"
+        
+        return Response(
+            generate_stream(),
+            content_type='text/event-stream',
+            headers={
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Headers': 'Content-Type, Authorization'
+            }
+        )
+        
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+if __name__ == "__main__":
+    # For local development
+    port = int(os.environ.get("API_PORT", 8000))
+    print(f"🚀 Starting API server on port {port}")
+    app.run(host="0.0.0.0", port=port, debug=False)

app.py

@@ -1,11 +1,162 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
+import logging
+import gc
+import warnings
+import os
+from config import MODEL_CONFIGS, DEFAULT_MODEL, MODEL_SETTINGS, GENERATION_DEFAULTS, MEDICAL_SYSTEM_PROMPT, UI_CONFIG
 
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
+# Suppress warnings
+warnings.filterwarnings("ignore")
+logging.getLogger("transformers").setLevel(logging.ERROR)
 
+# Global variables for model and tokenizer
+model = None
+tokenizer = None
+current_model_name = None
+
+def load_model(model_key=None):
+    """Load the specified medical model with optimizations for Hugging Face Spaces"""
+    global model, tokenizer, current_model_name
+    
+    if model_key is None:
+        model_key = DEFAULT_MODEL
+    
+    # Try to load models in order of preference
+    model_keys_to_try = [model_key, "meditron", "dialogpt_medium", "dialogpt_small"]
+    
+    for key in model_keys_to_try:
+        if key not in MODEL_CONFIGS:
+            continue
+            
+        try:
+            model_config = MODEL_CONFIGS[key]
+            model_name = model_config["name"]
+            print(f"Attempting to load model: {model_name} ({model_config['description']})")
+            
+            # Load tokenizer first
+            print("Loading tokenizer...")
+            tokenizer = AutoTokenizer.from_pretrained(
+                model_name,
+                trust_remote_code=MODEL_SETTINGS["trust_remote_code"],
+                padding_side="left"
+            )
+            
+            # Add pad token if it doesn't exist
+            if tokenizer.pad_token is None:
+                tokenizer.pad_token = tokenizer.eos_token
+            
+            # Configure quantization for memory efficiency (only for larger models)
+            model_kwargs = {
+                "trust_remote_code": MODEL_SETTINGS["trust_remote_code"],
+                "low_cpu_mem_usage": MODEL_SETTINGS["low_cpu_mem_usage"]
+            }
+            
+            # Add quantization for larger models
+            if MODEL_SETTINGS["use_quantization"] and key in ["medllama2", "meditron", "clinical_camel"]:
+                quantization_config = BitsAndBytesConfig(
+                    load_in_4bit=True,
+                    bnb_4bit_compute_dtype=torch.float16,
+                    bnb_4bit_quant_type="nf4",
+                    bnb_4bit_use_double_quant=True,
+                )
+                model_kwargs["quantization_config"] = quantization_config
+                model_kwargs["torch_dtype"] = torch.float16
+                model_kwargs["device_map"] = MODEL_SETTINGS["device_map"]
+            else:
+                # For smaller models, use regular loading
+                if torch.cuda.is_available():
+                    model_kwargs["torch_dtype"] = torch.float16
+                    model_kwargs["device_map"] = "auto"
+            
+            print("Loading model...")
+            model = AutoModelForCausalLM.from_pretrained(model_name, **model_kwargs)
+            
+            current_model_name = model_name
+            print(f"✅ Model loaded successfully: {model_name}")
+            return True
+            
+        except Exception as e:
+            print(f"❌ Failed to load {key}: {str(e)}")
+            # Clean up on failure
+            model = None
+            tokenizer = None
+            continue
+    
+    print("❌ All model loading attempts failed")
+    return False
+
+def generate_response(prompt, max_tokens=None, temperature=None, top_p=None):
+    """Generate response using the loaded model"""
+    global model, tokenizer, current_model_name
+    
+    if model is None or tokenizer is None:
+        return "❌ Model not loaded. Please wait for initialization or try restarting the space."
+    
+    # Use defaults if not specified
+    max_tokens = max_tokens or GENERATION_DEFAULTS["max_new_tokens"]
+    temperature = temperature or GENERATION_DEFAULTS["temperature"]
+    top_p = top_p or GENERATION_DEFAULTS["top_p"]
+    
+    try:
+        # Use the medical system prompt
+        full_prompt = f"{MEDICAL_SYSTEM_PROMPT}\n\nPatient/User: {prompt}\nMedical Assistant:"
+        
+        # Tokenize input with proper truncation
+        inputs = tokenizer(
+            full_prompt, 
+            return_tensors="pt", 
+            truncation=True, 
+            max_length=1024,
+            padding=True
+        )
+        
+        # Move to appropriate device
+        device = next(model.parameters()).device
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+        
+        # Generation parameters
+        generation_kwargs = {
+            "max_new_tokens": min(max_tokens, 1024),  # Cap at 1024 for safety
+            "temperature": temperature,
+            "top_p": top_p,
+            "do_sample": GENERATION_DEFAULTS["do_sample"],
+            "pad_token_id": tokenizer.eos_token_id,
+            "repetition_penalty": GENERATION_DEFAULTS["repetition_penalty"],
+            "no_repeat_ngram_size": GENERATION_DEFAULTS["no_repeat_ngram_size"]
+        }
+        
+        # Generate response
+        print(f"Generating response with {current_model_name}...")
+        with torch.no_grad():
+            outputs = model.generate(**inputs, **generation_kwargs)
+        
+        # Decode response
+        full_response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        # Extract only the new generated text
+        if "Medical Assistant:" in full_response:
+            response = full_response.split("Medical Assistant:")[-1].strip()
+        else:
+            # Fallback extraction
+            response = full_response[len(full_prompt):].strip()
+        
+        # Clean up response
+        if not response or len(response.strip()) < 10:
+            response = "I understand you're asking about a medical topic. While I'd like to help, I recommend consulting with a qualified healthcare professional who can provide personalized advice based on your specific situation."
+        
+        # Clean up memory
+        del inputs, outputs
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        
+        return response
+        
+    except Exception as e:
+        error_msg = f"Error generating response: {str(e)}"
+        print(error_msg)
+        return f"⚠️ I encountered a technical issue while processing your request. Please try again or rephrase your question. If the problem persists, consider consulting a healthcare professional directly."
 
 def respond(
     message,
@@ -15,50 +166,127 @@ def respond(
     temperature,
     top_p,
 ):
-    messages = [{"role": "system", "content": system_message}]
-
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
+    """Main response function for Gradio ChatInterface"""
+    if not message or not message.strip():
+        return "Please enter a medical question or concern."
+    
+    # Add a disclaimer for first-time users
+    disclaimer = "\n\n⚠️ **Medical Disclaimer**: This AI provides general health information only. Always consult healthcare professionals for medical advice, diagnosis, or treatment."
+    
+    try:
+        # Generate response
+        response = generate_response(
+            message.strip(),
+            max_tokens=int(max_tokens),
+            temperature=float(temperature),
+            top_p=float(top_p)
+        )
+        
+        # Add disclaimer to response
+        if "disclaimer" not in response.lower() and "consult" not in response.lower():
+            response += disclaimer
+        
+        return response
+        
+    except Exception as e:
+        error_msg = f"System error: {str(e)}"
+        print(error_msg)
+        return f"⚠️ System temporarily unavailable. Please try again later or consult a healthcare professional directly.{disclaimer}"
 
-    messages.append({"role": "user", "content": message})
+def get_model_info():
+    """Get information about the currently loaded model"""
+    if current_model_name:
+        return f"Currently using: {current_model_name}"
+    return "No model loaded"
 
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
+def respond(
+    message,
+    history: list[tuple[str, str]],
+    system_message,
+    max_tokens,
+    temperature,
+    top_p,
+):
+    """Main response function for Gradio ChatInterface"""
+    if not message or not message.strip():
+        return "Please enter a medical question or concern."
+    
+    # Add a disclaimer for first-time users
+    disclaimer = "\n\n⚠️ **Medical Disclaimer**: This AI provides general health information only. Always consult healthcare professionals for medical advice, diagnosis, or treatment."
+    
+    try:
+        # Generate response
+        response = generate_response(
+            message.strip(),
+            max_tokens=int(max_tokens),
+            temperature=float(temperature),
+            top_p=float(top_p)
+        )
+        
+        # Add disclaimer to response
+        if "disclaimer" not in response.lower() and "consult" not in response.lower():
+            response += disclaimer
+        
+        return response
+        
+    except Exception as e:
+        error_msg = f"System error: {str(e)}"
+        print(error_msg)
+        return f"⚠️ System temporarily unavailable. Please try again later or consult a healthcare professional directly.{disclaimer}"
 
-        response += token
-        yield response
+# Load model on startup
+print("🏥 Initializing MedLLaMA2 Medical Chatbot...")
+print("📋 Loading medical language model...")
+model_loaded = load_model()
 
+if model_loaded:
+    print(f"✅ Ready! {get_model_info()}")
+else:
+    print("⚠️ WARNING: Model failed to load. The app will run but responses may be limited.")
 
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
+# Create Gradio interface with configuration
 demo = gr.ChatInterface(
     respond,
+    title=UI_CONFIG["title"],
+    description=UI_CONFIG["description"],
     additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
+        gr.Textbox(
+            value=MEDICAL_SYSTEM_PROMPT,
+            label="System Instructions",
+            lines=4,
+            interactive=False  # Make it read-only to prevent tampering
+        ),
+        gr.Slider(
+            minimum=UI_CONFIG["max_tokens_range"][0], 
+            maximum=UI_CONFIG["max_tokens_range"][1], 
+            value=GENERATION_DEFAULTS["max_new_tokens"], 
+            step=10, 
+            label="Max new tokens"
+        ),
+        gr.Slider(
+            minimum=UI_CONFIG["temperature_range"][0], 
+            maximum=UI_CONFIG["temperature_range"][1], 
+            value=GENERATION_DEFAULTS["temperature"], 
+            step=0.1, 
+            label="Temperature (creativity)"
+        ),
         gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
+            minimum=UI_CONFIG["top_p_range"][0],
+            maximum=UI_CONFIG["top_p_range"][1],
+            value=GENERATION_DEFAULTS["top_p"],
             step=0.05,
-            label="Top-p (nucleus sampling)",
+            label="Top-p (focus)",
         ),
     ],
+    examples=[[example] for example in UI_CONFIG["examples"]],
+    cache_examples=False,
+    theme=gr.themes.Soft(),
+    css=".gradio-container {max-width: 900px; margin: auto;}"
 )
 
+# Add model info to the interface
+with demo:
+    gr.HTML(f"<p style='text-align: center; color: #666; font-size: 0.9em;'>Model Status: {get_model_info()}</p>")
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(server_name="0.0.0.0", server_port=7860, show_error=True)

combined_app.py

@@ -0,0 +1,36 @@
+"""
+Combined App for MedLLaMA2 Medical Chatbot
+This file runs both the Gradio interface and Flask API server
+"""
+
+import threading
+import time
+import subprocess
+import sys
+import os
+
+def run_gradio():
+    """Run the Gradio app"""
+    subprocess.run([sys.executable, "app.py"])
+
+def run_api():
+    """Run the API server"""
+    # Wait a bit for the model to load in Gradio
+    time.sleep(10)
+    subprocess.run([sys.executable, "api_server.py"])
+
+if __name__ == "__main__":
+    print("🚀 Starting MedLLaMA2 Combined Server...")
+    print("📊 This will start both Gradio UI (port 7860) and API server (port 8000)")
+    
+    # Create threads for both servers
+    gradio_thread = threading.Thread(target=run_gradio)
+    api_thread = threading.Thread(target=run_api)
+    
+    # Start both threads
+    gradio_thread.start()
+    api_thread.start()
+    
+    # Wait for both to complete
+    gradio_thread.join()
+    api_thread.join()

config.py

@@ -0,0 +1,84 @@
+# Configuration file for MedLLaMA2 model hosting
+
+# Model configurations
+MODEL_CONFIGS = {
+    # Primary medical models (replace with actual MedLLaMA2 when available)
+    "medllama2": {
+        "name": "medllama2:latest",  # Replace with actual MedLLaMA2 model ID
+        "description": "MedLLaMA2 7B medical language model"
+    },
+    
+    # Alternative medical models
+    "meditron": {
+        "name": "epfl-llm/meditron-7b",
+        "description": "Meditron 7B medical language model"
+    },
+    
+    "clinical_camel": {
+        "name": "wanglab/ClinicalCamel-70B",  # Note: This is very large, might not fit
+        "description": "Clinical Camel medical model"
+    },
+    
+    # Fallback models (smaller, more reliable)
+    "dialogpt_medium": {
+        "name": "microsoft/DialoGPT-medium",
+        "description": "DialoGPT Medium (fallback)"
+    },
+    
+    "dialogpt_small": {
+        "name": "microsoft/DialoGPT-small",
+        "description": "DialoGPT Small (lightweight fallback)"
+    }
+}
+
+# Default model to use
+DEFAULT_MODEL = "medllama2"
+
+# Model loading settings
+MODEL_SETTINGS = {
+    "use_quantization": True,
+    "quantization_bits": 4,
+    "torch_dtype": "float16",
+    "trust_remote_code": True,
+    "low_cpu_mem_usage": True,
+    "device_map": "auto"
+}
+
+# Generation settings
+GENERATION_DEFAULTS = {
+    "max_new_tokens": 512,
+    "temperature": 0.7,
+    "top_p": 0.9,
+    "do_sample": True,
+    "repetition_penalty": 1.1,
+    "no_repeat_ngram_size": 3
+}
+
+# Medical prompt template
+MEDICAL_SYSTEM_PROMPT = """You are a helpful medical AI assistant designed to provide accurate medical information and guidance. 
+
+Key guidelines:
+1. Provide factual, evidence-based medical information
+2. Always emphasize the importance of consulting healthcare professionals
+3. Never provide specific diagnoses or treatment recommendations
+4. Encourage users to seek immediate medical attention for serious symptoms
+5. Be empathetic and supportive while maintaining medical accuracy
+
+Remember: This information is for educational purposes only and should not replace professional medical advice."""
+
+# UI settings
+UI_CONFIG = {
+    "title": "🏥 MedLLaMA2 Medical Chatbot",
+    "description": "A medical AI assistant powered by MedLLaMA2. Please note: This is for educational purposes only and should not replace professional medical advice.",
+    "examples": [
+        "What are the symptoms of diabetes?",
+        "How can I maintain a healthy heart?",
+        "What should I know about blood pressure?",
+        "Tell me about the importance of regular exercise.",
+        "What are the side effects of common pain medications?",
+        "How can I improve my sleep quality?"
+    ],
+    "max_tokens_range": (50, 1024),
+    "temperature_range": (0.1, 1.0),
+    "top_p_range": (0.1, 1.0)
+}

requirements.txt

@@ -1,4 +1,8 @@
-huggingface_hub==0.25.2
-transformers
-torch
-accelerate
+gradio>=4.0.0
+transformers>=4.35.0
+torch>=2.0.0
+accelerate>=0.20.0
+bitsandbytes>=0.41.0
+sentencepiece>=0.1.99
+protobuf>=3.20.0
+huggingface_hub>=0.17.0