Add application file

Dockerfile

@@ -0,0 +1,34 @@
+FROM python:3.9-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    git \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create cache directory for models
+RUN mkdir -p /app/cache
+
+# Set environment variables
+ENV HF_HOME=/app/cache
+ENV TRANSFORMERS_CACHE=/app/cache
+ENV GRADIO_SERVER_NAME=0.0.0.0
+ENV GRADIO_SERVER_PORT=7860
+
+# Expose port
+EXPOSE 7860
+
+# Run the application
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,281 @@
+import gradio as gr
+import json
+import time
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import torch
+from chemistry_llm import ChemistryReactionExtractor
+import warnings
+warnings.filterwarnings('ignore')
+
+# Global variables
+extractor = None
+model_loading = False
+
+def load_model():
+    """Load the RxNExtract model"""
+    global extractor, model_loading
+    
+    if model_loading:
+        return "Model is currently loading, please wait..."
+    
+    if extractor is not None:
+        return "Model already loaded!"
+    
+    model_loading = True
+    try:
+        # Initialize the extractor
+        extractor = ChemistryReactionExtractor.from_pretrained(
+            "chemplusx/rxnextract-complete",
+            device="cuda" if torch.cuda.is_available() else "cpu",
+            load_in_4bit=True,
+            temperature=0.1,
+            max_length=512
+        )
+        model_loading = False
+        return "✅ RxNExtract model loaded successfully!"
+    except Exception as e:
+        model_loading = False
+        return f"❌ Error loading model: {str(e)}"
+
+def analyze_procedure(procedure_text, include_confidence=True, temperature=0.1):
+    """Analyze a chemical procedure"""
+    global extractor
+    
+    if extractor is None:
+        return "Please load the model first!", "", "", ""
+    
+    if not procedure_text.strip():
+        return "Please enter a chemical procedure to analyze.", "", "", ""
+    
+    try:
+        start_time = time.time()
+        
+        # Analyze the procedure
+        results = extractor.analyze_procedure(
+            procedure_text,
+            return_raw=False,
+            temperature=temperature
+        )
+        
+        processing_time = time.time() - start_time
+        
+        # Format the results
+        formatted_output = format_extraction_results(results)
+        
+        # Create visualizations
+        entity_plot = create_entity_visualization(results)
+        confidence_plot = create_confidence_visualization(results, processing_time)
+        
+        # Create summary
+        summary = create_summary(results, processing_time)
+        
+        return summary, formatted_output, entity_plot, confidence_plot
+        
+    except Exception as e:
+        error_msg = f"❌ Error during analysis: {str(e)}"
+        return error_msg, "", "", ""
+
+def format_extraction_results(results):
+    """Format extraction results for display"""
+    data = results['extracted_data']
+    
+    output = []
+    output.append("## 📊 Extraction Results\n")
+    output.append(f"**🎯 Confidence:** {results['confidence']:.1%}")
+    output.append(f"**⏱️ Processing Time:** {results['processing_time']:.1f}s\n")
+    
+    # Reactants
+    if data.get('reactants'):
+        output.append("### 🔵 Reactants")
+        for i, reactant in enumerate(data['reactants'], 1):
+            name = reactant.get('name', 'Unknown')
+            amount = reactant.get('amount', 'N/A')
+            output.append(f"{i}. **{name}** - Amount: {amount}")
+        output.append("")
+    
+    # Reagents
+    if data.get('reagents'):
+        output.append("### 🟡 Reagents")
+        for i, reagent in enumerate(data['reagents'], 1):
+            name = reagent.get('name', 'Unknown')
+            amount = reagent.get('amount', 'N/A')
+            output.append(f"{i}. **{name}** - Amount: {amount}")
+        output.append("")
+    
+    # Solvents
+    if data.get('solvents'):
+        output.append("### 🔵 Solvents")
+        for i, solvent in enumerate(data['solvents'], 1):
+            name = solvent.get('name', 'Unknown')
+            amount = solvent.get('amount', 'N/A')
+            output.append(f"{i}. **{name}** - Amount: {amount}")
+        output.append("")
+    
+    # Products
+    if data.get('products'):
+        output.append("### 🟢 Products")
+        for i, product in enumerate(data['products'], 1):
+            name = product.get('name', 'Unknown')
+            amount = product.get('amount', 'N/A')
+            yield_val = product.get('yield', 'N/A')
+            output.append(f"{i}. **{name}** - Amount: {amount}, Yield: {yield_val}")
+        output.append("")
+    
+    # Conditions
+    if data.get('conditions'):
+        output.append("### 🌡️ Reaction Conditions")
+        conditions = data['conditions']
+        for key, value in conditions.items():
+            if value:
+                output.append(f"- **{key.title()}:** {value}")
+        output.append("")
+    
+    # Workup steps
+    if data.get('workup'):
+        output.append("### ⚗️ Workup Steps")
+        for i, step in enumerate(data['workup'], 1):
+            output.append(f"{i}. {step}")
+        output.append("")
+    
+    return "\n".join(output)
+
+def create_entity_visualization(results):
+    """Create entity count visualization"""
+    data = results['extracted_data']
+    
+    # Count entities
+    entity_counts = {
+        'Reactants': len(data.get('reactants', [])),
+        'Reagents': len(data.get('reagents', [])),
+        'Solvents': len(data.get('solvents', [])),
+        'Products': len(data.get('products', [])),
+        'Conditions': len([v for v in data.get('conditions', {}).values() if v]),
+        'Workup Steps': len(data.get('workup', []))
+    }
+    
+    # Remove zero counts
+    entity_counts = {k: v for k, v in entity_counts.items() if v > 0}
+    
+    if not entity_counts:
+        return None
+    
+    # Create bar chart
+    fig = px.bar(
+        x=list(entity_counts.keys()),
+        y=list(entity_counts.values()),
+        title="Extracted Chemical Entities",
+        labels={'x': 'Entity Type', 'y': 'Count'},
+        color=list(entity_counts.keys()),
+        color_discrete_sequence=px.colors.qualitative.Set3
+    )
+    
+    fig.update_layout(
+        showlegend=False,
+        height=400,
+        title_x=0.5,
+        xaxis_tickangle=-45
+    )
+    
+    return fig
+
+def create_confidence_visualization(results, processing_time):
+    """Create confidence and timing visualization"""
+    confidence = results['confidence']
+    
+    # Create gauge chart for confidence
+    fig = go.Figure(go.Indicator(
+        mode = "gauge+number+delta",
+        value = confidence * 100,
+        domain = {'x': [0, 1], 'y': [0, 1]},
+        title = {'text': "Confidence Score (%)"},
+        delta = {'reference': 80},
+        gauge = {
+            'axis': {'range': [None, 100]},
+            'bar': {'color': "darkblue"},
+            'steps': [
+                {'range': [0, 50], 'color': "lightgray"},
+                {'range': [50, 80], 'color': "yellow"},
+                {'range': [80, 100], 'color': "green"}],
+            'threshold': {
+                'line': {'color': "red", 'width': 4},
+                'thickness': 0.75,
+                'value': 90}}))
+    
+    fig.update_layout(
+        height=300,
+        title=f"Processing Time: {processing_time:.1f}s"
+    )
+    
+    return fig
+
+def create_summary(results, processing_time):
+    """Create a summary of the analysis"""
+    data = results['extracted_data']
+    confidence = results['confidence']
+    
+    total_entities = sum([
+        len(data.get('reactants', [])),
+        len(data.get('reagents', [])),
+        len(data.get('solvents', [])),
+        len(data.get('products', []))
+    ])
+    
+    confidence_level = "High" if confidence >= 0.8 else "Medium" if confidence >= 0.6 else "Low"
+    
+    summary = f"""
+## 📈 Analysis Summary
+
+**🎯 Overall Performance:**
+- **Confidence Level:** {confidence_level} ({confidence:.1%})
+- **Processing Speed:** {processing_time:.1f} seconds
+- **Total Entities Extracted:** {total_entities}
+
+**📊 Extraction Breakdown:**
+- **Reactants:** {len(data.get('reactants', []))}
+- **Products:** {len(data.get('products', []))}
+- **Reagents:** {len(data.get('reagents', []))}
+- **Solvents:** {len(data.get('solvents', []))}
+- **Conditions:** {len([v for v in data.get('conditions', {}).values() if v])}
+- **Workup Steps:** {len(data.get('workup', []))}
+
+**💡 Quality Assessment:**
+{get_quality_assessment(confidence, total_entities)}
+"""
+    
+    return summary
+
+def get_quality_assessment(confidence, total_entities):
+    """Get quality assessment based on confidence and entities"""
+    if confidence >= 0.8 and total_entities >= 3:
+        return "✅ Excellent extraction quality with high confidence and comprehensive entity recognition."
+    elif confidence >= 0.6 and total_entities >= 2:
+        return "✅ Good extraction quality with moderate confidence. Results are reliable."
+    elif confidence >= 0.4:
+        return "⚠️ Moderate extraction quality. Some information may be missing or uncertain."
+    else:
+        return "❌ Low extraction quality. Consider reviewing the procedure text for clarity."
+
+def get_example_procedures():
+    """Get example procedures for the interface"""
+    examples = [
+        """Add 2.5 g of benzoic acid to 50 mL of ethanol in a round-bottom flask.
+Heat the mixture to reflux for 4 hours while stirring.
+Cool the solution to room temperature and filter the precipitate.
+Wash the solid with cold ethanol and dry to obtain 2.1 g of product (84% yield).""",
+        
+        """Dissolve 10.0 g of 4-nitroaniline in 200 mL of concentrated HCl.
+Add 15.0 g of tin powder portionwise while maintaining temperature below 10°C.
+Stir for 2 hours at room temperature, then heat to 60°C for 1 hour.
+Neutralize with NaOH solution and extract with ethyl acetate (3 × 50 mL).
+Dry over MgSO4 and concentrate to give 7.2 g of product (78% yield).""",
+        
+        """In a round-bottom flask, combine 5.0 mmol of styrene, 6.0 mmol of phenylboronic acid,
+and 0.1 mmol of Pd(PPh3)4 catalyst in 20 mL of DMF.
+Add 15.0 mmol of K2CO3 and heat to 100°C under nitrogen atmosphere.
+Stir for 12 hours, then cool and filter through celite.
+Purify by column chromatography to obtain 0.85 g of biphenyl derivative (92% yield)."""
+    ]
+    return examples

requirements.txt

@@ -0,0 +1,9 @@
+gradio==4.44.0
+torch>=1.9.0
+transformers>=4.20.0
+rxnextract>=1.2.0
+pandas>=1.3.0
+plotly>=5.0.0
+numpy>=1.21.0
+scikit-learn>=1.0.0
+scipy>=1.7.0