Upload 4 files

Files to kick off this new space

document_analyzer.py

@@ -0,0 +1,277 @@
+# document_analyzer.py
+# Enhanced document analysis module for healthcare fraud detection with Llama 4
+
+import torch
+import re
+from typing import List, Dict, Any
+import nltk
+from nltk.tokenize import sent_tokenize
+
+try:
+    nltk.data.find('tokenizers/punkt')
+except LookupError:
+    nltk.download('punkt')
+
+class HealthcareFraudAnalyzer:
+    def __init__(self, model, processor, device=None):
+        self.model = model
+        self.processor = processor
+        self.device = device if device else "cuda" if torch.cuda.is_available() else "cpu"
+        self.model.to(self.device)
+        self.model.eval()
+        
+        self.fraud_categories = [
+            "Consent violations",
+            "Documentation issues",
+            "Visitation restrictions",
+            "Medication misuse",
+            "Chemical restraint",
+            "Fraudulent billing",
+            "False testimony",
+            "Information concealment",
+            "Patient neglect",
+            "Hospice certification issues"
+        ]
+        
+        self.key_terms = {
+            "medication": ["haloperidol", "lorazepam", "sedation", "chemical", "restraint", 
+                         "prn", "as needed", "antipsychotic", "sedative", "benadryl", 
+                         "ativan", "seroquel", "comfort kit", "medication"],
+            "documentation": ["record", "documentation", "log", "chart", "note", "missing", 
+                           "altered", "backdated", "omit", "selective", "inconsistent"],
+            "visitation": ["visit", "restriction", "limit", "family", "spouse", "access", 
+                         "barrier", "monitor", "disruptive", "uncooperative"],
+            "consent": ["consent", "authorize", "approval", "permission", "against wishes", 
+                     "refused", "decline", "without knowledge"],
+            "hospice": ["hospice", "terminal", "end of life", "palliative", "comfort care", 
+                      "six months", "6 months", "prognosis", "certification"],
+            "billing": ["charge", "bill", "payment", "medicare", "medicaid", "insurance", 
+                      "reimbursement", "fee", "additional", "extra"]
+        }
+    
+    def chunk_document(self, text: str, chunk_size: int = 1024, overlap: int = 256) -> List[str]:
+        sentences = sent_tokenize(text)
+        chunks = []
+        current_chunk = ""
+        
+        for sentence in sentences:
+            if len(current_chunk) + len(sentence) <= chunk_size:
+                current_chunk += sentence + " "
+            else:
+                chunks.append(current_chunk.strip())
+                overlap_start = max(0, len(current_chunk) - overlap)
+                current_chunk = current_chunk[overlap_start:] + sentence + " "
+        
+        if current_chunk.strip():
+            chunks.append(current_chunk.strip())
+            
+        return chunks
+    
+    def analyze_chunk(self, chunk: str) -> Dict[str, Any]:
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": f"""Analyze the following healthcare document text for evidence of fraud, neglect, abuse, or criminal conduct.
+Focus on: {', '.join(self.fraud_categories)}.
+Provide specific indicators and cite the relevant text.
+
+DOCUMENT TEXT:
+{chunk}
+
+ANALYSIS:"""
+                    }
+                ]
+            }
+        ]
+        
+        inputs = self.processor.apply_chat_template(
+            messages,
+            add_generation_prompt=True,
+            tokenize=True,
+            return_dict=True,
+            return_tensors="pt"
+        ).to(self.device)
+        
+        with torch.no_grad():
+            output = self.model.generate(
+                **inputs,
+                max_new_tokens=512,
+                temperature=0.1,
+                top_p=0.9,
+                repetition_penalty=1.2
+            )
+        
+        response = self.processor.batch_decode(output[:, inputs["input_ids"].shape[-1]:])[0]
+        analysis = response.strip()
+        
+        term_matches = self._find_key_terms(chunk)
+        
+        return {
+            "analysis": analysis,
+            "term_matches": term_matches,
+            "chunk_text": chunk[:200] + "..." if len(chunk) > 200 else chunk
+        }
+    
+    def _find_key_terms(self, text: str) -> Dict[str, List[str]]:
+        text = text.lower()
+        results = {}
+        
+        for category, terms in self.key_terms.items():
+            matches = []
+            for term in terms:
+                pattern = r'.{0,50}' + re.escape(term) + r'.{0,50}'
+                for match in re.finditer(pattern, text):
+                    matches.append("..." + match.group(0) + "...")
+            
+            if matches:
+                results[category] = matches
+                
+        return results
+    
+    def analyze_document(self, document_text: str) -> Dict[str, Any]:
+        document_text = document_text.replace('\n', ' ').replace('\r', ' ')
+        document_text = re.sub(r'\s+', ' ', document_text)
+        
+        chunks = self.chunk_document(document_text)
+        chunk_analyses = [self.analyze_chunk(chunk) for chunk in chunks]
+        consolidated_findings = self._consolidate_analyses(chunk_analyses)
+        
+        return {
+            "summary": self._generate_summary(consolidated_findings, document_text),
+            "detailed_findings": consolidated_findings,
+            "chunk_analyses": chunk_analyses,
+            "document_metadata": {
+                "length": len(document_text),
+                "chunk_count": len(chunks)
+            }
+        }
+    
+    def _consolidate_analyses(self, chunk_analyses: List[Dict[str, Any]]) -> Dict[str, Any]:
+        all_term_matches = {category: [] for category in self.key_terms.keys()}
+        
+        for analysis in chunk_analyses:
+            for category, matches in analysis.get("term_matches", {}).items():
+                all_term_matches[category].extend(matches)
+        
+        for category in all_term_matches:
+            if all_term_matches[category]:
+                deduplicated = []
+                for match in all_term_matches[category]:
+                    if not any(match in other and match != other for other in all_term_matches[category]):
+                        deduplicated.append(match)
+                all_term_matches[category] = deduplicated[:5]
+        
+        categorized_findings = {category: [] for category in self.fraud_categories}
+        
+        for analysis in chunk_analyses:
+            analysis_text = analysis.get("analysis", "")
+            for category in self.fraud_categories:
+                if category.lower() in analysis_text.lower():
+                    sentences = sent_tokenize(analysis_text)
+                    relevant = [s for s in sentences if category.lower() in s.lower()]
+                    if relevant:
+                        categorized_findings[category].extend(relevant)
+        
+        return {
+            "term_matches": all_term_matches,
+            "categorized_findings": categorized_findings
+        }
+    
+    def _generate_summary(self, findings: Dict[str, Any], full_text: str) -> str:
+        indicator_counts = {
+            category: len(findings["categorized_findings"].get(category, []))
+            for category in self.fraud_categories
+        }
+        
+        term_match_counts = {
+            category: len(matches) 
+            for category, matches in findings["term_matches"].items()
+        }
+        
+        sorted_categories = sorted(
+            self.fraud_categories,
+            key=lambda x: indicator_counts.get(x, 0) + term_match_counts.get(x, 0),
+            reverse=True
+        )
+        
+        summary_lines = ["# Healthcare Fraud Detection Analysis", ""]
+        summary_lines.append("## Key Concerns Identified")
+        
+        for category in sorted_categories[:3]:
+            if indicator_counts.get(category, 0) > 0 or term_match_counts.get(category, 0) > 0:
+                summary_lines.append(f"### {category}")
+                
+                if findings["categorized_findings"].get(category):
+                    summary_lines.append("Model analysis indicates:")
+                    for finding in findings["categorized_findings"].get(category, [])[:3]:
+                        summary_lines.append(f"- {finding}")
+                
+                category_lower = category.lower().rstrip('s')
+                for term_category, matches in findings["term_matches"].items():
+                    if category_lower in term_category.lower() and matches:
+                        summary_lines.append(f"Key terms identified:")
+                        for match in matches[:3]:
+                            summary_lines.append(f"- {match}")
+                
+                summary_lines.append("")
+        
+        summary_lines.append("## Recommended Actions")
+        if sum(indicator_counts.values()) > 5:
+            summary_lines.append("- **Urgent review recommended** - Multiple indicators of potential fraud detected")
+            summary_lines.append("- Consider referral to appropriate regulatory authorities")
+            summary_lines.append("- Document preservation should be prioritized")
+        elif sum(indicator_counts.values()) > 2:
+            summary_lines.append("- **Further investigation recommended** - Several potential indicators identified")
+            summary_lines.append("- Conduct interviews with involved personnel")
+            summary_lines.append("- Secure additional documentation for verification")
+        else:
+            summary_lines.append("- **Monitor situation** - Limited indicators detected")
+            summary_lines.append("- Consider more specific document analysis")
+        
+        return "\n".join(summary_lines)
+    
+    def print_report(self, results: Dict[str, Any]) -> None:
+        print("\n" + "="*80)
+        print("HEALTHCARE FRAUD DETECTION REPORT")
+        print("="*80 + "\n")
+        
+        print(results["summary"])
+        
+        print("\n" + "="*80)
+        print("DETAILED FINDINGS")
+        print("="*80)
+        
+        for category, findings in results["detailed_findings"]["categorized_findings"].items():
+            if findings:
+                print(f"\n## {category.upper()}")
+                for i, finding in enumerate(findings, 1):
+                    print(f"{i}. {finding}")
+        
+        print("\n" + "="*80)
+        print("KEY TERM MATCHES")
+        print("="*80)
+        
+        for category, matches in results["detailed_findings"]["term_matches"].items():
+            if matches:
+                print(f"\n## {category.upper()}")
+                for match in matches:
+                    print(f"- {match}")
+                    
+        print("\n" + "="*80 + "\n")
+
+def analyze_pdf_for_fraud(pdf_path, model, processor):
+    import pdfplumber
+    
+    with pdfplumber.open(pdf_path) as pdf:
+        text = ""
+        for page in pdf.pages:
+            text += page.extract_text() or ""
+    
+    analyzer = HealthcareFraudAnalyzer(model, processor)
+    results = analyzer.analyze_document(text)
+    
+    analyzer.print_report(results)
+    return results

requirements.txt

@@ -0,0 +1 @@
+torch>=2.0.0 transformers>=4.51.0 datasets>=2.14.0 gradio>=4.0.0 pdfplumber>=0.10.0 peft>=0.14.0 bitsandbytes>=0.41.0 huggingface_hub>=0.19.0 accelerate>=0.21.0 nltk>=3.8.0

train_llama4.py

@@ -0,0 +1,128 @@
+# train_llama4.py
+# Script to fine-tune Llama 4 Maverick for healthcare fraud detection
+
+from transformers import AutoProcessor, Llama4ForConditionalGeneration, Trainer, TrainingArguments
+from transformers import BitsAndBytesConfig
+import datasets
+import torch
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+from accelerate import Accelerator
+import huggingface_hub
+import os
+
+# Version and CUDA check
+print(f"PyTorch version: {torch.__version__}")
+print(f"CUDA version: {torch.version.cuda}")
+print(f"Is CUDA available: {torch.cuda.is_available()}")
+print(f"CUDA device: {torch.cuda.get_device_name(torch.cuda.current_device())}")
+
+# Authenticate with Hugging Face
+LLama = os.getenv("LLama")
+if not LLama:
+    raise ValueError("LLama token not found. Set it in Hugging Face Space secrets as 'LLama'.")
+huggingface_hub.login(token=LLama)
+
+# Load Llama 4 model and processor
+MODEL_ID = "meta-llama/Llama-4-Maverick-17B-128E-Instruct"
+processor = AutoProcessor.from_pretrained(MODEL_ID, trust_remote_code=True)
+
+# Quantization config for A100 80 GB VRAM
+quantization_config = BitsAndBytesConfig(load_in_8bit=True)
+
+model = Llama4ForConditionalGeneration.from_pretrained(
+    MODEL_ID,
+    torch_dtype=torch.bfloat16,
+    device_map="auto",
+    quantization_config=quantization_config,
+    attn_implementation="flex_attention"
+)
+
+# Prepare for LoRA
+model = prepare_model_for_kbit_training(model)
+peft_config = LoraConfig(
+    r=16,
+    lora_alpha=32,
+    lora_dropout=0.05,
+    bias="none",
+    task_type="CAUSAL_LM",
+    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"]
+)
+model = get_peft_model(model, peft_config)
+model.print_trainable_parameters()
+
+# Load dataset
+dataset = datasets.load_dataset("json", data_files="Bingaman_training_data.json", field="training_pairs")
+print("First example from dataset:", dataset["train"][0])
+
+# Tokenization
+def tokenize_data(example):
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "text", "text": example['input']}]
+        },
+        {
+            "role": "assistant",
+            "content": [{"type": "text", "text": example['output']}]
+        }
+    ]
+    formatted_text = processor.apply_chat_template(messages, add_generation_prompt=False)
+    inputs = processor(formatted_text, padding="max_length", truncation=True, max_length=4096, return_tensors="pt")
+    input_ids = inputs["input_ids"].squeeze(0).tolist()
+    attention_mask = inputs["attention_mask"].squeeze(0).tolist()
+    labels = input_ids.copy()
+    return {
+        "input_ids": input_ids,
+        "labels": labels,
+        "attention_mask": attention_mask
+    }
+
+tokenized_dataset = dataset["train"].map(tokenize_data, batched=False, remove_columns=dataset["train"].column_names)
+print("First tokenized example:", {k: (type(v), len(v)) for k, v in tokenized_dataset[0].items()})
+
+# Data collator
+def custom_data_collator(features):
+    input_ids = [torch.tensor(f["input_ids"]) for f in features]
+    attention_mask = [torch.tensor(f["attention_mask"]) for f in features]
+    labels = [torch.tensor(f["labels"]) for f in features]
+    return {
+        "input_ids": torch.stack(input_ids),
+        "attention_mask": torch.stack(attention_mask),
+        "labels": torch.stack(labels)
+    }
+
+# Training setup
+accelerator = Accelerator()
+training_args = TrainingArguments(
+    output_dir="./fine_tuned_llama4_healthcare",
+    per_device_train_batch_size=2,
+    gradient_accumulation_steps=8,
+    eval_strategy="steps",
+    eval_steps=10,
+    save_strategy="steps",
+    save_steps=20,
+    save_total_limit=3,
+    num_train_epochs=5,
+    learning_rate=2e-5,
+    weight_decay=0.01,
+    logging_dir="./logs",
+    logging_steps=5,
+    bf16=True,
+    gradient_checkpointing=True,
+    optim="adamw_torch",
+    warmup_steps=50
+)
+
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=tokenized_dataset,
+    eval_dataset=tokenized_dataset.select(range(min(5, len(tokenized_dataset)))),
+    data_collator=custom_data_collator
+)
+
+# Start training
+trainer.train()
+model.save_pretrained("./fine_tuned_llama4_healthcare")
+processor.save_pretrained("./fine_tuned_llama4_healthcare")
+print("Training complete. Model and processor saved to ./fine_tuned_llama4_healthcare")

updated_app.py

@@ -0,0 +1,272 @@
+# updated_app.py
+# Enhanced Gradio app for Llama 4 Maverick healthcare fraud detection
+
+import gradio as gr
+from transformers import AutoProcessor, Llama4ForConditionalGeneration
+import datasets
+import torch
+import json
+import os
+import pdfplumber
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+from accelerate import Accelerator
+import huggingface_hub
+import re
+import nltk
+from nltk.tokenize import sent_tokenize
+
+try:
+    nltk.data.find('tokenizers/punkt')
+except LookupError:
+    nltk.download('punkt')
+
+# Import the HealthcareFraudAnalyzer
+from document_analyzer import HealthcareFraudAnalyzer
+
+# Debug: Print environment variables to verify 'LLama' is present
+print("Environment variables:", dict(os.environ))
+
+# Retrieve the token from Hugging Face Space secrets
+LLama = os.getenv("LLama")
+if not LLama:
+    raise ValueError("LLama token not found. Set it in Hugging Face Space secrets as 'LLama'.")
+
+# Debug: Print token (first 5 chars for security, remove in production)
+print(f"Retrieved LLama token: {LLama[:5]}...")
+
+# Authenticate with Hugging Face
+huggingface_hub.login(token=LLama)
+
+# Model setup
+MODEL_ID = "meta-llama/Llama-4-Maverick-17B-128E-Instruct"
+processor = AutoProcessor.from_pretrained(MODEL_ID, trust_remote_code=True)
+
+# Load model with FP8 quantization to fit in 80 GB VRAM
+model = Llama4ForConditionalGeneration.from_pretrained(
+    MODEL_ID,
+    torch_dtype=torch.bfloat16,
+    device_map="auto",
+    quantization_config={"load_in_8bit": True},
+    attn_implementation="flex_attention"
+)
+
+# Prepare model for LoRA training
+model = prepare_model_for_kbit_training(model)
+peft_config = LoraConfig(
+    r=16,
+    lora_alpha=32,
+    lora_dropout=0.05,
+    bias="none",
+    task_type="CAUSAL_LM",
+    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"]
+)
+model = get_peft_model(model, peft_config)
+model.print_trainable_parameters()
+
+# Function to create training pairs from document text
+def extract_training_pairs_from_text(text):
+    pairs = []
+    patterns = [
+        # Medication patterns
+        (
+            r"(?i).*?\b(haloperidol|lorazepam|ativan)\b.*?\b(daily|routine|regular)\b.*?",
+            "Patient receives {} on a {} basis. Is this appropriate medication management?",
+            "This may indicate inappropriate medication management. Regular use of psychotropic medications without documented need assessment, behavior monitoring, and attempted dose reductions may violate care standards."
+        ),
+        # Documentation patterns
+        (
+            r"(?i).*?\b(missing|omitted|absent|lacking)\b.*?\b(documentation|records|logs|notes)\b.*?",
+            "Facility has {} {} for patient care. Is this a documentation concern?",
+            "Yes, incomplete documentation is a significant red flag. Missing records may indicate attempts to conceal care issues or fraudulent billing for services not provided."
+        ),
+        # Visitation patterns
+        (
+            r"(?i).*?\b(restrict|limit|prevent|block)\b.*?\b(visits|visitation|access|family)\b.*?",
+            "Facility {} family {} without documented medical necessity. Is this suspicious?",
+            "Yes, unjustified visitation restrictions may indicate attempts to conceal care issues and prevent family oversight. This can constitute fraud when facilities bill for care while violating resident rights."
+        ),
+        # Hospice patterns
+        (
+            r"(?i).*?\b(hospice|terminal|end.of.life)\b.*?\b(not|without|lacking)\b.*?\b(evidence|decline|documentation)\b.*?",
+            "Patient placed on {} care {} supporting {}. Is this fraudulent?",
+            "Yes, hospice enrollment without documented terminal decline may indicate Medicare fraud. Hospice certification requires genuine clinical determination of terminal status with prognosis of six months or less."
+        ),
+        # Contradictory documentation
+        (
+            r"(?i).*?\b(different|contradicts|conflicts|inconsistent)\b.*?\b(records|documentation|testimony|statements)\b.*?",
+            "Records show {} {} about patient condition. Is this fraudulent documentation?",
+            "Yes, contradictory documentation is a strong indicator of fraudulent record-keeping designed to misrepresent care quality or patient condition, particularly when official records differ from internal communications."
+        )
+    ]
+
+    for pattern, input_template, output_text in patterns:
+        matches = re.finditer(pattern, text)
+        for match in matches:
+            groups = match.groups()
+            if len(groups) >= 2:
+                input_text = input_template.format(*groups)
+                pairs.append({
+                    "input": input_text,
+                    "output": output_text
+                })
+
+    if not pairs:
+        if any(x in text.lower() for x in ["medication", "prescribed", "administered"]):
+            pairs.append({
+                "input": "Medication records show inconsistencies in administration times. Is this concerning?",
+                "output": "Yes, inconsistent medication administration timing may indicate fraudulent documentation or medication mismanagement that could harm patients."
+            })
+        if any(x in text.lower() for x in ["visit", "family", "spouse"]):
+            pairs.append({
+                "input": "Staff documents family visits inconsistently. Is this suspicious?",
+                "output": "Yes, selective documentation of family visits indicates fraudulent record-keeping designed to create a false narrative about family involvement and patient responses."
+            })
+        if any(x in text.lower() for x in ["hospice", "terminal", "prognosis"]):
+            pairs.append({
+                "input": "Patient remained on hospice for extended period without documented decline. Is this Medicare fraud?",
+                "output": "Yes, maintaining hospice services without documented decline suggests fraudulent hospice certification to obtain Medicare benefits inappropriately."
+            })
+
+    return pairs
+
+# Function to process uploaded files and train
+def train_ui(files):
+    try:
+        raw_text = ""
+        dataset = None
+        for file in files:
+            if file.name.endswith(".pdf"):
+                with pdfplumber.open(file.name) as pdf:
+                    for page in pdf.pages:
+                        raw_text += page.extract_text() or ""
+            elif file.name.endswith(".json"):
+                with open(file.name, "r", encoding="utf-8") as f:
+                    raw_data = json.load(f)
+                    training_data = raw_data.get("training_pairs", raw_data)
+                    with open("temp_fraud_data.json", "w", encoding="utf-8") as f:
+                        json.dump({"training_pairs": training_data}, f)
+                    dataset = datasets.load_dataset("json", data_files="temp_fraud_data.json")
+
+        if not raw_text and not dataset:
+            return "Error: No valid PDF or JSON data found."
+
+        if raw_text:
+            training_data = extract_training_pairs_from_text(raw_text)
+            with open("temp_fraud_data.json", "w") as f:
+                json.dump({"training_pairs": training_data}, f)
+            dataset = datasets.load_dataset("json", data_files="temp_fraud_data.json")
+
+        def tokenize_data(example):
+            messages = [
+                {
+                    "role": "user",
+                    "content": [{"type": "text", "text": example['input']}]
+                },
+                {
+                    "role": "assistant",
+                    "content": [{"type": "text", "text": example['output']}]
+                }
+            ]
+            formatted_text = processor.apply_chat_template(messages, add_generation_prompt=False)
+            inputs = processor(formatted_text, padding="max_length", truncation=True, max_length=4096, return_tensors="pt")
+            inputs["labels"] = inputs["input_ids"].clone()
+            return {k: v.squeeze(0) for k, v in inputs.items()}
+
+        tokenized_dataset = dataset["train"].map(tokenize_data, batched=True, remove_columns=dataset["train"].column_names)
+
+        training_args = TrainingArguments(
+            output_dir="./fine_tuned_llama4_healthcare",
+            per_device_train_batch_size=2,
+            gradient_accumulation_steps=8,
+            eval_strategy="no",
+            save_strategy="epoch",
+            save_total_limit=2,
+            num_train_epochs=5,
+            learning_rate=2e-5,
+            weight_decay=0.01,
+            logging_dir="./logs",
+            logging_steps=10,
+            bf16=True,
+            gradient_checkpointing=True,
+            optim="adamw_torch",
+            warmup_steps=100,
+        )
+
+        def custom_data_collator(features):
+            return {
+                "input_ids": torch.stack([f["input_ids"] for f in features]),
+                "attention_mask": torch.stack([f["attention_mask"] for f in features]),
+                "labels": torch.stack([f["labels"] for f in features]),
+            }
+
+        trainer = Trainer(
+            model=model,
+            args=training_args,
+            train_dataset=tokenized_dataset,
+            data_collator=custom_data_collator,
+        )
+
+        trainer.train()
+        model.save_pretrained("./fine_tuned_llama4_healthcare")
+        processor.save_pretrained("./fine_tuned_llama4_healthcare")
+        return f"Training completed with {len(tokenized_dataset)} examples! Model saved to ./fine_tuned_llama4_healthcare"
+
+    except Exception as e:
+        return f"Error: {str(e)}. Please check file format, dependencies, or the LLama token."
+
+# Function to analyze uploaded document for fraud
+def analyze_document_ui(files):
+    try:
+        if not files:
+            return "Error: No file uploaded. Please upload a PDF to analyze."
+        
+        file = files[0]
+        if not file.name.endswith(".pdf"):
+            return "Error: Please upload a PDF file for analysis."
+        
+        raw_text = ""
+        with pdfplumber.open(file.name) as pdf:
+            for page in pdf.pages:
+                raw_text += page.extract_text() or ""
+        
+        if not raw_text:
+            return "Error: Could not extract text from the PDF. The file may be corrupt or contain only images."
+        
+        analyzer = HealthcareFraudAnalyzer(model, processor)
+        results = analyzer.analyze_document(raw_text)
+        return results["summary"]
+    
+    except Exception as e:
+        return f"Error during document analysis: {str(e)}"
+
+# Gradio UI with training and analysis tabs
+with gr.Blocks(title="Healthcare Fraud Detection Suite") as demo:
+    gr.Markdown("# Healthcare Fraud Detection Suite")
+    
+    with gr.Tabs():
+        with gr.TabItem("Fine-Tune Model"):
+            gr.Markdown("## Train Llama 4 for Healthcare Fraud Detection")
+            gr.Markdown("Upload PDFs (e.g., care logs, medication records) or a JSON file with training pairs.")
+            train_file_input = gr.File(label="Upload Files (PDF/JSON)", file_count="multiple")
+            train_button = gr.Button("Start Fine-Tuning")
+            train_output = gr.Textbox(label="Training Status", lines=5)
+            train_button.click(fn=train_ui, inputs=train_file_input, outputs=train_output)
+        
+        with gr.TabItem("Analyze Document"):
+            gr.Markdown("## Analyze Document for Healthcare Fraud Indicators")
+            gr.Markdown("Upload a PDF document to analyze for potential fraud, neglect, or abuse indicators.")
+            analyze_file_input = gr.File(label="Upload PDF Document")
+            analyze_button = gr.Button("Analyze Document")
+            analyze_output = gr.Markdown(label="Analysis Results")
+            analyze_button.click(fn=analyze_document_ui, inputs=analyze_file_input, outputs=analyze_output)
+    
+    gr.Markdown("""
+    ### About This Tool
+    This tool uses Llama 4 Maverick to identify patterns of potential fraud, neglect, and abuse in healthcare documentation.
+    The fine-tuning tab allows model customization with your examples or automatic extraction from documents.
+    The analysis tab scans documents for suspicious patterns, generating detailed reports.
+    **Note:** All analysis is performed locally - no data is shared externally.
+    """)
+
+# Launch the Gradio app
+demo.launch()