using the transformers

Dockerfile

@@ -1,18 +0,0 @@
-FROM python:3.10-slim
-
-WORKDIR /app
-
-# Install only what you actually need
-RUN apt-get update && \
-    apt-get install -y libopenblas-dev && \
-    rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt .
-RUN pip install --upgrade pip
-# This will pull the prebuilt CPU wheels
-RUN pip install --no-cache-dir -r requirements.txt
-
-COPY . .
-
-EXPOSE 7860
-CMD ["python", "app.py"]

README.md

@@ -7,7 +7,174 @@ sdk: gradio
 sdk_version: 5.39.0
 app_file: app.py
 pinned: false
-hardware: cpu
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+
+# 🦷 Dental AI Assistant
+
+An advanced dental consultation and medication extraction system powered by AI. This application provides dental advice, medication recommendations, and intelligent text analysis for medical documents.
+
+## ✨ Features
+
+- **🩺 Dental Consultation**: Get AI-powered dental advice with detailed medication regimens
+- **💊 Medication Extraction**: Extract and highlight medications from medical text using NLP
+- **🎨 Interactive Visualization**: Visual representation of extracted medication entities
+- **⚡ Quick Questions**: Pre-built common dental questions for instant answers
+- **⚙️ Customizable Settings**: Adjust response length and creativity parameters
+- **🚀 GPU/CPU Support**: Automatic device detection and optimization
+- **📱 Modern UI**: Clean, responsive Gradio interface
+
+## 🛠️ Installation
+
+### Prerequisites
+
+- Python 3.8+
+- CUDA-compatible GPU (optional, for faster inference)
+
+### Step 1: Clone the Repository
+
+```bash
+git clone https://huggingface.co/spaces/iprashantsmp/Dental_AI_Assistant/
+cd Dental_AI_Assistant
+```
+
+### Step 2: Install Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+
+### Step 3: Get API Keys
+
+**Gemini API Key** (required for medication extraction):
+1. Go to [Google AI Studio](https://aistudio.google.com)
+2. Click 'Get API Key'
+3. Create a new API key
+4. Keep it secure for use in the application
+
+## 🚀 Usage
+
+### Running the Application
+
+```bash
+gradio app.py
+```
+
+The application will start on `http://127.0.0.1:7860`
+
+### Features Overview
+
+#### 1. Dental Consultation Tab
+- Ask dental questions and receive AI-powered advice
+- Get detailed 3-day medication regimens
+- Use quick questions for common dental issues
+- Adjust response parameters (max tokens, temperature)
+
+#### 2. Medication Extraction Tab
+- Paste medical text to extract medication information
+- Get highlighted text with identified entities
+- View interactive visualizations of extracted data
+- Export results for further analysis
+
+#### 3. Help & Setup Tab
+- Complete setup instructions
+- API key configuration guide
+- Feature documentation
+
+## 🔧 Configuration
+
+### Model Settings
+
+The application uses the `yasserrmd/DentaInstruct-1.2B` model from Hugging Face:
+
+- **Model Type**: Causal Language Model
+- **Framework**: Transformers
+- **Device**: Auto-detected (GPU/CPU)
+- **Precision**: Float16 (GPU) / Float32 (CPU)
+
+### Generation Parameters
+
+- **Max Tokens**: 500-4000 (default: 2048)
+- **Temperature**: 0.1-1.0 (default: 0.7)
+- **Top-p**: 0.9 (fixed)
+- **Do Sample**: True
+
+## 📁 Project Structure
+
+```
+dental-ai-assistant/
+├── app.py                    # Main application file
+├── requirements.txt          # Python dependencies
+├── README.md                # This file
+```
+
+## 🔑 API Keys Setup
+
+### Gemini API Key
+
+1. Visit [Google AI Studio](https://aistudio.google.com)
+2. Sign in with your Google account
+3. Navigate to "Get API Key"
+4. Create a new project or select existing
+5. Generate API key
+6. Copy and use in the application
+
+**Note**: Keep your API keys secure and never commit them to version control.
+
+## 🎯 Quick Start Examples
+
+### Example 1: Dental Consultation
+```
+Question: "I have a severe toothache with swelling, provide 3-day medication"
+
+Expected Response: Detailed medication regimen including:
+- Antibiotics (dosage, frequency, duration)
+- Pain relievers (mechanism of action)
+- Anti-inflammatory medications
+- Professional consultation disclaimer
+```
+
+### Example 2: Medication Extraction
+```
+Input Text: "Patient prescribed 500mg Amoxicillin TID for 7 days and 400mg Ibuprofen QID PRN for pain"
+
+Expected Output:
+- Medication: Amoxicillin, Ibuprofen
+- Dosage: 500mg, 400mg
+- Frequency: TID, QID PRN
+- Duration: 7 days, as needed
+```
+
+## 🚨 Important Disclaimers
+
+⚠️ **Medical Disclaimer**: This AI assistant is for educational purposes only. Always consult with a qualified dentist or healthcare professional for medical advice, diagnosis, or treatment.
+
+⚠️ **Accuracy**: While the AI strives for accuracy, medical information should always be verified with healthcare professionals.
+
+⚠️ **Emergency**: For dental emergencies, contact your dentist or emergency services immediately.
+
+
+### Performance Optimization
+
+- **For faster inference**: Use GPU with CUDA
+- **For lower memory usage**: Reduce max_tokens and batch size
+- **For better accuracy**: Increase temperature for more creative responses
+
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- **Model**: [yasserrmd/DentaInstruct-1.2B](https://huggingface.co/yasserrmd/DentaInstruct-1.2B)
+- **Framework**: [Hugging Face Transformers](https://huggingface.co/transformers/)
+- **UI**: [Gradio](https://gradio.app/)
+- **NLP**: [LangExtract](https://github.com/google/langextract)
+- **API**: [Google Gemini](https://ai.google.dev/)
+
+
+**Built with ❤️ for the dental community**

app.py

@@ -1,5 +1,5 @@
 import gradio as gr
-from llama_cpp import Llama
+from transformers import AutoTokenizer, AutoModelForCausalLM
 import langextract as lx
 import json
 import re
@@ -10,44 +10,51 @@ import time
 import os
 from pathlib import Path
 import tempfile
+import torch
 
-# Global variable to store the loaded model and token
+# Global variables to store the loaded model and tokenizer
 dental_model = None
+dental_tokenizer = None
 current_token = None
 output_directory = Path(".")
 
-def load_dental_gguf_model():
-    """Load the dental GGUF model"""
-    global dental_model
-    if dental_model is None:
+def load_dental_transformers_model():
+    """Load the dental model using transformers"""
+    global dental_model, dental_tokenizer
+    if dental_model is None or dental_tokenizer is None:
         try:
-            print("Loading GGUF model... This may take a moment on first run.")
-            dental_model = Llama.from_pretrained(
-                repo_id="yasserrmd/DentaInstruct-1.2B-gguf",
-                filename="DentaInstruct-1.2B-Q4_K_M.gguf",
-                verbose=False,
-                n_ctx=4096,
-                n_threads=4,
+            print("Loading transformers model... This may take a moment on first run.")
+            
+            # Load tokenizer and model
+            dental_tokenizer = AutoTokenizer.from_pretrained("yasserrmd/DentaInstruct-1.2B")
+            dental_model = AutoModelForCausalLM.from_pretrained(
+                "yasserrmd/DentaInstruct-1.2B",
+                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+                device_map="auto" if torch.cuda.is_available() else None
             )
+            
+            # Set pad token if not set
+            if dental_tokenizer.pad_token is None:
+                dental_tokenizer.pad_token = dental_tokenizer.eos_token
+            
             print("Model loaded successfully!")
-            return dental_model
+            return dental_model, dental_tokenizer
         except Exception as e:
-            print(f"Error loading GGUF model: {str(e)}")
-            return None
-    return dental_model
+            print(f"Error loading transformers model: {str(e)}")
+            return None, None
+    return dental_model, dental_tokenizer
 
 def generate_dental_response(
     question: str, 
     max_tokens: int = 2048, 
     temperature: float = 0.7
 ) -> str:
-    """Generate response using GGUF model"""
-    
+    """Generate response using transformers model"""
     
-    # Load model with the provided token
-    llm = load_dental_gguf_model()
-    if not llm:
-        return "❌ GGUF model not available."
+    # Load model and tokenizer
+    model, tokenizer = load_dental_transformers_model()
+    if not model or not tokenizer:
+        return "❌ Transformers model not available."
     
     try:
         system_prompt = """You are a dental AI assistant. When providing medication recommendations, you must:
@@ -61,17 +68,57 @@ def generate_dental_response(
             {"role": "user", "content": question}
         ]
         
-        response = llm.create_chat_completion(
-            messages=messages,
-            max_tokens=max_tokens,
-            temperature=temperature,
-            top_p=0.9
+        # Apply chat template
+        try:
+            # Try with chat template first
+            input_text = tokenizer.apply_chat_template(
+                messages,
+                add_generation_prompt=True,
+                tokenize=False
+            )
+        except:
+            # Fallback to simple concatenation if chat template fails
+            input_text = f"{system_prompt}\n\nUser: {question}\n\nAssistant:"
+        
+        # Tokenize the input
+        inputs = tokenizer(
+            input_text,
+            return_tensors="pt",
+            padding=True,
+            truncation=True,
+            max_length=2048
+        )
+        
+        # Remove token_type_ids if present (not needed for most models)
+        if 'token_type_ids' in inputs:
+            del inputs['token_type_ids']
+        
+        # Move to device
+        inputs = {k: v.to(model.device) for k, v in inputs.items()}
+        
+        # Generate response
+        with torch.no_grad():
+            outputs = model.generate(
+                input_ids=inputs['input_ids'],
+                attention_mask=inputs['attention_mask'],
+                max_new_tokens=max_tokens,
+                temperature=temperature,
+                top_p=0.9,
+                do_sample=True,
+                pad_token_id=tokenizer.eos_token_id,
+                eos_token_id=tokenizer.eos_token_id
+            )
+        
+        # Decode only the new tokens (response)
+        response = tokenizer.decode(
+            outputs[0][inputs['input_ids'].shape[-1]:], 
+            skip_special_tokens=True
         )
         
-        return response['choices'][0]['message']['content'].strip()
+        return response.strip()
         
     except Exception as e:
-        return f"❌ Error generating response with GGUF model: {str(e)}"
+        return f"❌ Error generating response with transformers model: {str(e)}"
 
 def extract_medications(text: str, gemini_api_key: str = "") -> Tuple[str, str, str]:
     """Extract medication information from text"""
@@ -290,9 +337,9 @@ def create_gradio_interface():
                         
                         gr.Markdown("""
                         **Model Info:**
-                        - Using GGUF Model
-                        - Optimized for performance
-                        - Requires HF token for access
+                        - Using Transformers Model
+                        - Optimized for GPU/CPU
+                        - Auto device mapping
                         """)
                 
                 response_output = gr.Textbox(
@@ -372,7 +419,7 @@ def create_gradio_interface():
                 ## 🚀 Getting Started
                 
                 ### Model:
-                **GGUF Model**: Faster, more efficient, works offline after download
+                **Transformers Model**: Uses HuggingFace transformers library with automatic device mapping
                 
                 ### 🔑 API Key Setup:
                 
@@ -383,7 +430,7 @@ def create_gradio_interface():
                 
                 ### 📦 Installation Requirements:
                 ```bash
-                pip install gradio llama-cpp-python langextract pandas requests
+                pip install gradio transformers langextract pandas requests torch
                 ```
                 
                 ### 🩺 Features:
@@ -392,6 +439,7 @@ def create_gradio_interface():
                 - **Interactive Visualization**: Visual representation of extracted medication entities
                 - **Quick Questions**: Pre-built common dental questions
                 - **Customizable Settings**: Adjust response length and creativity
+                - **GPU/CPU Support**: Automatic device detection and optimization
                 
                 ### ⚠️ Important Disclaimer:
                 This AI assistant is for educational purposes only. Always consult with a qualified dentist for professional medical advice.
@@ -403,7 +451,7 @@ def create_gradio_interface():
             <p><strong>⚠️ Disclaimer:</strong> This AI assistant is for educational purposes only. 
             Always consult with a qualified dentist for professional medical advice.</p>
             <p style="text-align: center; margin-top: 1rem;">
-                🦷 Built with Gradio | Powered by DentaInstruct-1.2B
+                🦷 Built with Gradio | Gemini | Powered by yasserrmd/DentaInstruct-1.2B
             </p>
         </div>
         """)
@@ -416,6 +464,5 @@ if __name__ == "__main__":
     demo.queue()
     demo.launch(
         share=False,
-        show_error=True,
-        enable_queue=True
+        show_error=True
     )

requirements.txt

@@ -1,6 +1,8 @@
-gradio==5.39.0
-llama-cpp-python==0.3.14
+gradio
+transformers
+torch
 langextract==1.0.3
 pandas
 numpy
-requests
+requests
+accelerate