Upload folder using huggingface_hub

README.md

@@ -1,195 +1,165 @@
 ---
-title: PharmaDDI Environment - Drug Interaction Checker
+title: PharmaDDIEnv
 emoji: 💊
 colorFrom: blue
 colorTo: purple
 sdk: docker
-pinned: false
-app_port: 8000
+app_port: 7860
 base_path: /web
-tags:
-  - openenv
 ---
 
-# PharmaDDI Environment - Pharmaceutical Drug Interaction Checker
+# PharmaDDI: Clinical Drug-Drug Interaction RL Environment
 
-A clinical pharmacist RL environment where an AI agent reviews patient medication lists and identifies dangerous **drug-drug interactions (DDIs)**. Medication errors cause ~7,000 deaths/year in the US, making automated DDI checking a high-impact real-world application.
+### Empowering AI Agents to Prevent Adverse Drug Events in Complex Polypharmacy
 
-## Motivation
+---
 
-Polypharmacy (multiple concurrent medications) is extremely common in elderly patients. Manual drug interaction checking is time-consuming and error-prone. This environment trains and evaluates AI agents on this critical clinical task.
+## Motivation & Real-World Utility
 
-## Quick Start
+Drug-Drug Interactions (DDIs) are a major cause of preventable medical errors, hospitalizations, and mortality worldwide. As patients age and develop multiple chronic conditions, the complexity of their medication regimens (polypharmacy) increases significantly.
 
-```python
-from PharmaDDIEnv import PharmaDDIAction, PharmaDDIEnv, InteractionReport
-
-# Create environment from Docker image
-env = PharmaDDIEnv.from_docker_image("PharmaDDIEnv-env:latest")
-
-try:
-    result = env.reset()
-    print(f"Patient: {result.observation.patient_id}")
-    print(f"Medications: {[m.name for m in result.observation.medications]}")
-
-    # Submit interaction analysis
-    action = PharmaDDIAction(interactions_found=[
-        InteractionReport(
-            drug_a="warfarin", drug_b="aspirin",
-            severity="major",
-            clinical_effect="Increased bleeding risk",
-            recommendation="monitor"
-        )
-    ])
-    result = env.step(action)
-    print(f"Score: {result.observation.score}")
-    print(f"Feedback: {result.observation.feedback}")
-finally:
-    env.close()
-```
+In a typical clinical workflow, a pharmacist must:
 
-## Building & Running
+1. Identify all interacting drug pairs within a list of medications
+2. Assess the clinical severity of each interaction
+3. Recommend appropriate actions to reduce patient risk while maintaining treatment effectiveness
 
-```bash
-# Build Docker image
-docker build -t PharmaDDIEnv-env:latest -f server/Dockerfile .
+PharmaDDI provides a clinically grounded reinforcement learning (RL) environment to benchmark AI agents on these critical healthcare decision-making tasks.
 
-# Run locally (development)
-uvicorn server.app:app --reload --host 0.0.0.0 --port 8000
+---
 
-# Deploy to HF Spaces
-openenv push
+## Environment Overview
+
+The PharmaDDI environment provides an agent with a structured patient profile that includes:
+
+* Demographics (age and medical conditions)
+* Medication list (drug name, class, dosage, and frequency)
+
+The goal of the agent is to detect and report all clinically significant drug-drug interactions, simulating the reasoning process of a clinical pharmacist.
+
+---
+
+## Observation Space
+
+The agent receives a structured observation object:
+
+```python
+class MedicationInfo(BaseModel):
+    name: str
+    therapeutic_class: str
+    common_dose: str
+    frequency: str
+
+class PharmaDDIObservation(Observation):
+    patient_id: str
+    patient_age: int
+    patient_conditions: List[str]
+    medications: List[MedicationInfo]
+    num_medications: int
+    instructions: str
 ```
 
+---
+
 ## Action Space
 
-**`PharmaDDIAction`** - Agent's drug interaction analysis:
+The agent returns detected interactions in the following format:
 
-| Field | Type | Description |
-|-------|------|-------------|
-| `interactions_found` | `List[InteractionReport]` | List of identified DDI pairs |
+```python
+class InteractionReport(BaseModel):
+    drug_a: str
+    drug_b: str
+    severity: str  # minor | moderate | major | contraindicated
+    clinical_effect: str
+    recommendation: str  # monitor | adjust_dose | substitute | discontinue
+
+class PharmaDDIAction(Action):
+    interactions_found: List[InteractionReport]
+```
+
+---
 
-Each **`InteractionReport`** contains:
+## Tasks & Evaluation
 
-| Field | Type | Values |
-|-------|------|--------|
-| `drug_a` | `str` | Drug name (lowercase) |
-| `drug_b` | `str` | Drug name (lowercase) |
-| `severity` | `str` | `minor` \| `moderate` \| `major` \| `contraindicated` |
-| `clinical_effect` | `str` | Description of the interaction mechanism |
-| `recommendation` | `str` | `monitor` \| `adjust_dose` \| `substitute` \| `discontinue` |
+The environment includes three levels of difficulty:
 
-## Observation Space
+| Task ID           | Medications | Objective                           | Difficulty |
+| ----------------- | ----------- | ----------------------------------- | ---------- |
+| easy_pair_check   | 2           | Detect interaction for a given pair | Easy       |
+| medium_multi_drug | 5           | Identify all interacting pairs      | Medium     |
+| hard_polypharmacy | 8           | Handle complex multi-drug cases     | Hard       |
 
-**`PharmaDDIObservation`** - Patient scenario:
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `task_name` | `str` | `easy_pair_check` \| `medium_multi_drug` \| `hard_polypharmacy` |
-| `task_difficulty` | `str` | `easy` \| `medium` \| `hard` |
-| `patient_id` | `str` | Unique patient identifier |
-| `patient_age` | `int` | Patient age in years |
-| `patient_conditions` | `List[str]` | Medical conditions |
-| `medications` | `List[MedicationInfo]` | Current medication list |
-| `num_medications` | `int` | Number of medications |
-| `instructions` | `str` | Task-specific instructions |
-| `feedback` | `str` | Grading feedback after submission |
-| `score` | `float` | Score achieved (0.01.0) |
-| `total_interactions` | `int` | Hint for easy mode only |
-
-## Tasks
-
-### Task 1: Easy - Pair Check (2 drugs)
-- Given 2 medications, identify if a DDI exists
-- Classify severity level
-- **Scoring**: 60% pair identification + 40% severity  false positive penalty
-
-### Task 2: Medium - Multi-Drug Review (5 drugs)
-- Review 5 concurrent medications
-- Find ALL interacting pairs and classify severity
-- **Scoring**: 40% pairs + 35% severity + 10% recommendations + 15% precision  critical miss penalty
-
-### Task 3: Hard - Polypharmacy (8 drugs)
-- Complex elderly patient with 8 medications
-- Find all interactions, classify severity, AND recommend clinical actions
-- **Scoring**: 30% pairs + 25% severity + 25% recommendations + 10% precision + 10% completeness  critical miss penalty
+---
 
 ## Reward Function
 
-Rewards range from **0.0 to 1.0** per task with partial credit:
+A weighted scoring system (0.0 to 1.0) evaluates agent performance:
 
--  **Correct pair identification**: Points for each real DDI found
--  **Severity accuracy**: Full points for exact match, 50% for adjacent severity
--  **Recommendation quality** (medium/hard): Points for correct clinical action
--  **False positive penalty**: Deduction per hallucinated interaction
--  **Critical miss penalty**: Extra penalty for missing major/contraindicated interactions
+* Identification Accuracy (30–60%)
+* Severity Classification (25–40%)
+* Recommendation Quality (10–25%)
 
-## Drug Knowledge Base
+Penalties include:
 
-The environment includes **30 common drugs** across therapeutic classes:
-- Cardiovascular (warfarin, aspirin, clopidogrel, lisinopril, atorvastatin, etc.)
-- CNS/Psychiatric (fluoxetine, sertraline, diazepam, tramadol, lithium, etc.)
-- Antibiotics (ciprofloxacin, metronidazole, erythromycin, rifampin, etc.)
-- Analgesics (ibuprofen, naproxen, acetaminophen)
-- Diabetes (metformin, glipizide)
-- Other (omeprazole, levothyroxine, spironolactone)
+* False positives (incorrect interaction detection)
+* Missing critical interactions (major or contraindicated)
 
-With **60+ known DDI pairs** based on real clinical pharmacology.
+---
 
-## Baseline Inference
+## Example Workflow
 
-```bash
-export API_BASE_URL="https://api.openai.com/v1"
-export MODEL_NAME="gpt-4"
-export HF_TOKEN="your-api-key"
-python inference.py
-```
+1. Input: Patient with multiple medications
+2. Agent analyzes all possible drug pairs
+3. Outputs structured interaction reports
+4. Environment scores the response based on correctness
 
-### Expected Baseline Scores (GPT-4)
+---
 
-| Task | Expected Score | Difficulty |
-|------|---------------|------------|
-| `easy_pair_check` | ~0.851.0 | Easy |
-| `medium_multi_drug` | ~0.550.75 | Medium |
-| `hard_polypharmacy` | ~0.350.55 | Hard |
+## Setup & Usage
 
-## Project Structure
+### Local Development
 
+```bash
+pip install -e .
+uvicorn server.app:app --host 0.0.0.0 --port 8000
+python vall.py
 ```
-PharmaDDIEnv/
--- inference.py              # Baseline inference script
--- openenv.yaml              # OpenEnv manifest with 3 tasks
--- pyproject.toml             # Project metadata & dependencies
--- README.md                  # This file
--- models.py                  # Action/Observation Pydantic models
--- client.py                  # PharmaDDIEnv client
--- __init__.py                # Module exports
--- server/
-    -- drug_data.py           # Drug & interaction knowledge base
-    -- PharmaDDIEnv_environment.py  # Core environment + grading logic
-    -- app.py                 # FastAPI application
-    -- Dockerfile             # Container image definition
-    -- requirements.txt       # Server dependencies
-```
 
-## Setup Instructions
+---
+
+### Docker Deployment
 
-1. **Install dependencies**: `pip install openenv-core[core]`
-2. **Build Docker**: `docker build -t PharmaDDIEnv-env:latest -f server/Dockerfile .`
-3. **Run server**: `uvicorn server.app:app --host 0.0.0.0 --port 8000`
-4. **Validate**: `openenv validate`
-5. **Deploy**: `openenv push`
+```bash
+docker build -t pharmaddi-env:latest -f Dockerfile .
+docker run -p 8000:8000 pharmaddi-env:latest
+```
 
-## Deploying to Hugging Face Spaces
+---
+
+### Hugging Face Deployment
 
 ```bash
 openenv push
-# or with options:
-openenv push --repo-id your-username/PharmaDDIEnv --private
 ```
 
-The deployed space includes:
-- **Web Interface** at `/web`
-- **API Documentation** at `/docs`
-- **Health Check** at `/health`
-- **WebSocket** at `/ws`
+---
+
+## Project Structure
+
+| File                               | Description                               |
+| ---------------------------------- | ----------------------------------------- |
+| server/PharmaDDIEnv_environment.py | Core RL environment and grading logic     |
+| server/drug_data.py                | Drug database and interaction rules       |
+| models.py                          | Data schemas for observations and actions |
+| inference.py                       | Baseline agent implementation             |
+| openenv.yaml                       | OpenEnv configuration                     |
+
+---
+
+## License & Acknowledgements
+
+This project was developed for the Meta x Hugging Face OpenEnv Hackathon.
+
+The drug interaction knowledge base is derived from publicly available clinical sources and research literature.
+
+Disclaimer: This project is intended for research and educational purposes only. It should not be used for real clinical decision-making.

inference.py

@@ -21,7 +21,7 @@ MODEL_NAME = os.getenv("MODEL_NAME") or "Qwen/Qwen2.5-72B-Instruct"
 ENV_BASE_URL = os.getenv("ENV_BASE_URL") or "http://localhost:8000"
 
 BENCHMARK = "PharmaDDIEnv"
-MAX_STEPS = 1
+MAX_STEPS = 15
 TEMPERATURE = 0.1
 MAX_TOKENS = 500
 

server/PharmaDDIEnv_environment.py

@@ -284,7 +284,7 @@ class PharmaDDIEnvironment(Environment):
                 critical_penalty
             )
 
-        final_score = min(max(raw_score, 0.0), 1.0)
+        final_score = min(max(raw_score, 0.01), 0.99)
 
         # Build summary feedback
         summary = (