Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,40 @@
+# DGL Backend Dockerfile for MatGL HuggingFace Spaces
+# Reference: https://huggingface.co/docs/hub/en/spaces-sdks-docker
+
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies as root
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    libcurl4 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install dependencies AS ROOT (before creating user)
+# Exact versions from official matgl repo for compatibility
+RUN pip install --no-cache-dir "numpy<2"
+RUN pip install --no-cache-dir torch==2.3.0 --index-url https://download.pytorch.org/whl/cpu
+RUN pip install --no-cache-dir "torchdata<=0.8.0"
+RUN pip install --no-cache-dir dgl==2.2.0 -f https://data.dgl.ai/wheels/torch-2.3/repo.html
+RUN pip install --no-cache-dir matgl pymatgen gradio
+
+# Create non-root user AFTER installing packages
+RUN useradd -m -u 1000 user
+
+# Make /app writable by user (for model cache)
+RUN chown -R user:user /app
+
+# Switch to user for running
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH \
+    HF_HOME=/app/.cache \
+    MATGL_BACKEND=DGL
+
+# Copy app
+COPY --chown=user app.py /app/
+
+EXPOSE 7860
+
+CMD ["python", "app.py"]

README.md

@@ -1,10 +1,34 @@
 ---
-title: Matgl So3net
-emoji: 💻
-colorFrom: purple
-colorTo: red
+title: MatGL SO3Net
+emoji: 🔬
+colorFrom: blue
+colorTo: purple
 sdk: docker
-pinned: false
+app_port: 7860
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# MatGL SO3Net
+
+Material property prediction using **SO3Net-ANI-1x-Subset-PES** from the MatGL library.
+
+## API Endpoints
+
+- **Energy**: Predict total and per-atom energy
+- **Forces**: Predict atomic forces
+- **Stress**: Predict stress tensor
+- **Health**: Health check endpoint
+
+## Usage
+
+Paste a CIF structure and click Predict to get material properties.
+
+## Model Information
+
+- **Model**: `SO3Net-ANI-1x-Subset-PES`
+- **Library**: [MatGL](https://github.com/materialsvirtuallab/matgl)
+- **Backend**: DGL
+
+## Links
+
+- [MatGL Documentation](https://matgl.ai/)
+- [MKC-Holmes Project](https://github.com/materialsvirtuallab/matgl)

app.py

@@ -0,0 +1,370 @@
+"""
+MatGL PES Model Template (DGL Backend)
+Supports: Energy, Forces, Stress calculation via PESCalculator
+
+Replace MODEL_NAME with the actual model name, e.g.:
+- M3GNet-MP-2021.2.8-PES
+- CHGNet-MPtrj-2024.2.13-11M-PES
+"""
+import os
+import time
+
+# Set DGL backend BEFORE importing matgl (critical for v2.0+)
+os.environ["MATGL_BACKEND"] = "DGL"
+
+import gradio as gr
+import torch
+import numpy as np
+import dgl  # Import DGL explicitly to ensure it's loaded first
+import matgl
+
+# Also set via API (belt and suspenders)
+matgl.set_backend("DGL")
+
+# === CONFIGURATION ===
+MODEL_NAME = "SO3Net-ANI-1x-Subset-PES"  # Replace with actual model name
+SPACE_TITLE = "MatGL SO3Net"  # Replace with space title
+# =====================
+
+# Global model cache
+_model = None
+_model_error = None
+
+
+def get_model():
+    """Lazy load the model on first use."""
+    global _model, _model_error
+
+    if _model_error:
+        return None, _model_error
+
+    if _model is None:
+        try:
+            print(f"Loading {MODEL_NAME}...")
+            _model = matgl.load_model(MODEL_NAME)
+            print(f"{MODEL_NAME} loaded successfully.")
+        except Exception as e:
+            _model_error = str(e)
+            print(f"Failed to load model: {e}")
+            import traceback
+            traceback.print_exc()
+            return None, _model_error
+
+    return _model, None
+
+
+def predict_energy(cif_string: str) -> dict:
+    """Predict energy per atom from CIF string."""
+    if not cif_string or not cif_string.strip():
+        return {"status": "error", "message": "CIF string is empty"}
+
+    pot, error = get_model()
+    if error:
+        return {"status": "error", "message": f"Model load failed: {error}"}
+
+    try:
+        start_time = time.time()
+        from pymatgen.core import Structure
+        from pymatgen.io.ase import AseAtomsAdaptor
+        from matgl.ext.ase import PESCalculator
+
+        struct = Structure.from_str(cif_string, fmt="cif")
+        adaptor = AseAtomsAdaptor()
+        atoms = adaptor.get_atoms(struct)
+
+        calc = PESCalculator(potential=pot)
+        atoms.calc = calc
+
+        e_total = atoms.get_potential_energy()
+        e_per_atom = e_total / len(atoms)
+        elapsed_ms = (time.time() - start_time) * 1000
+
+        return {
+            "status": "success",
+            "formula": struct.composition.reduced_formula,
+            "num_atoms": len(struct),
+            "model": MODEL_NAME,
+            "model_type": "pes",
+            "properties": {
+                "energy_per_atom": {"value": round(e_per_atom, 4), "unit": "eV/atom"},
+                "total_energy": {"value": round(e_total, 4), "unit": "eV"},
+            },
+            "metadata": {
+                "backend": "DGL",
+                "computation_time_ms": round(elapsed_ms, 1),
+            },
+        }
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+
+def predict_forces(cif_string: str) -> dict:
+    """Predict forces from CIF string."""
+    if not cif_string or not cif_string.strip():
+        return {"status": "error", "message": "CIF string is empty"}
+
+    pot, error = get_model()
+    if error:
+        return {"status": "error", "message": f"Model load failed: {error}"}
+
+    try:
+        start_time = time.time()
+        from pymatgen.core import Structure
+        from pymatgen.io.ase import AseAtomsAdaptor
+        from matgl.ext.ase import PESCalculator
+
+        struct = Structure.from_str(cif_string, fmt="cif")
+        adaptor = AseAtomsAdaptor()
+        atoms = adaptor.get_atoms(struct)
+
+        calc = PESCalculator(potential=pot)
+        atoms.calc = calc
+
+        forces = atoms.get_forces()
+        elapsed_ms = (time.time() - start_time) * 1000
+
+        return {
+            "status": "success",
+            "formula": struct.composition.reduced_formula,
+            "num_atoms": len(struct),
+            "model": MODEL_NAME,
+            "model_type": "pes",
+            "properties": {
+                "forces": {
+                    "value": forces.tolist(),
+                    "unit": "eV/A",
+                    "shape": list(forces.shape),
+                },
+            },
+            "metadata": {
+                "backend": "DGL",
+                "computation_time_ms": round(elapsed_ms, 1),
+            },
+        }
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+
+def predict_stress(cif_string: str) -> dict:
+    """Predict stress tensor from CIF string."""
+    if not cif_string or not cif_string.strip():
+        return {"status": "error", "message": "CIF string is empty"}
+
+    pot, error = get_model()
+    if error:
+        return {"status": "error", "message": f"Model load failed: {error}"}
+
+    try:
+        start_time = time.time()
+        from pymatgen.core import Structure
+        from pymatgen.io.ase import AseAtomsAdaptor
+        from matgl.ext.ase import PESCalculator
+
+        struct = Structure.from_str(cif_string, fmt="cif")
+        adaptor = AseAtomsAdaptor()
+        atoms = adaptor.get_atoms(struct)
+
+        calc = PESCalculator(potential=pot)
+        atoms.calc = calc
+
+        # ASE returns stress in eV/A^3, convert to GPa
+        stress_voigt = atoms.get_stress()  # Voigt notation [xx, yy, zz, yz, xz, xy]
+        stress_gpa = stress_voigt * 160.21766208  # eV/A^3 to GPa
+        elapsed_ms = (time.time() - start_time) * 1000
+
+        return {
+            "status": "success",
+            "formula": struct.composition.reduced_formula,
+            "num_atoms": len(struct),
+            "model": MODEL_NAME,
+            "model_type": "pes",
+            "properties": {
+                "stress_voigt": {
+                    "value": stress_gpa.tolist(),
+                    "unit": "GPa",
+                    "order": ["xx", "yy", "zz", "yz", "xz", "xy"],
+                },
+            },
+            "metadata": {
+                "backend": "DGL",
+                "computation_time_ms": round(elapsed_ms, 1),
+            },
+        }
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+
+def predict_all(cif_string: str) -> dict:
+    """Predict all properties (energy, forces, stress) from CIF string."""
+    if not cif_string or not cif_string.strip():
+        return {"status": "error", "message": "CIF string is empty"}
+
+    pot, error = get_model()
+    if error:
+        return {"status": "error", "message": f"Model load failed: {error}"}
+
+    try:
+        start_time = time.time()
+        from pymatgen.core import Structure
+        from pymatgen.io.ase import AseAtomsAdaptor
+        from matgl.ext.ase import PESCalculator
+
+        struct = Structure.from_str(cif_string, fmt="cif")
+        adaptor = AseAtomsAdaptor()
+        atoms = adaptor.get_atoms(struct)
+
+        calc = PESCalculator(potential=pot)
+        atoms.calc = calc
+
+        e_total = atoms.get_potential_energy()
+        e_per_atom = e_total / len(atoms)
+        forces = atoms.get_forces()
+        stress_voigt = atoms.get_stress()
+        stress_gpa = stress_voigt * 160.21766208
+        elapsed_ms = (time.time() - start_time) * 1000
+
+        return {
+            "status": "success",
+            "formula": struct.composition.reduced_formula,
+            "num_atoms": len(struct),
+            "model": MODEL_NAME,
+            "model_type": "pes",
+            "properties": {
+                "energy_per_atom": {"value": round(e_per_atom, 4), "unit": "eV/atom"},
+                "total_energy": {"value": round(e_total, 4), "unit": "eV"},
+                "forces": {
+                    "value": forces.tolist(),
+                    "unit": "eV/A",
+                    "shape": list(forces.shape),
+                },
+                "stress_voigt": {
+                    "value": stress_gpa.tolist(),
+                    "unit": "GPa",
+                    "order": ["xx", "yy", "zz", "yz", "xz", "xy"],
+                },
+            },
+            "metadata": {
+                "backend": "DGL",
+                "computation_time_ms": round(elapsed_ms, 1),
+            },
+        }
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+
+def health_check() -> dict:
+    """Health check endpoint."""
+    pot, error = get_model()
+    if error:
+        return {"status": "error", "message": error}
+    return {"status": "healthy", "model": MODEL_NAME, "backend": "DGL"}
+
+
+def model_info() -> dict:
+    """Return model information."""
+    return {
+        "model": MODEL_NAME,
+        "backend": "DGL",
+        "model_type": "pes",
+        "capabilities": ["energy", "forces", "stress"],
+        "units": {
+            "energy": "eV",
+            "energy_per_atom": "eV/atom",
+            "forces": "eV/A",
+            "stress": "GPa",
+        },
+    }
+
+
+# Example NaCl CIF
+EXAMPLE_CIF = """data_NaCl
+_symmetry_space_group_name_H-M   'F m -3 m'
+_cell_length_a   5.64
+_cell_length_b   5.64
+_cell_length_c   5.64
+_cell_angle_alpha   90
+_cell_angle_beta   90
+_cell_angle_gamma   90
+loop_
+_atom_site_label
+_atom_site_type_symbol
+_atom_site_fract_x
+_atom_site_fract_y
+_atom_site_fract_z
+Na1 Na 0.0 0.0 0.0
+Cl1 Cl 0.5 0.5 0.5
+"""
+
+# Create Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown(f"# {SPACE_TITLE}")
+    gr.Markdown(f"PES model for energy, forces, and stress prediction using **{MODEL_NAME}**.")
+    gr.Markdown("**Note:** First prediction may take longer as the model loads on-demand.")
+
+    with gr.Tab("Energy"):
+        with gr.Row():
+            with gr.Column():
+                cif_energy = gr.Textbox(
+                    label="CIF Structure",
+                    placeholder="Paste CIF content here...",
+                    lines=10,
+                    value=EXAMPLE_CIF,
+                )
+                energy_btn = gr.Button("Predict Energy", variant="primary")
+            with gr.Column():
+                energy_output = gr.JSON(label="Result")
+        energy_btn.click(predict_energy, inputs=cif_energy, outputs=energy_output)
+
+    with gr.Tab("Forces"):
+        with gr.Row():
+            with gr.Column():
+                cif_forces = gr.Textbox(
+                    label="CIF Structure",
+                    placeholder="Paste CIF content here...",
+                    lines=10,
+                    value=EXAMPLE_CIF,
+                )
+                forces_btn = gr.Button("Predict Forces", variant="primary")
+            with gr.Column():
+                forces_output = gr.JSON(label="Result")
+        forces_btn.click(predict_forces, inputs=cif_forces, outputs=forces_output)
+
+    with gr.Tab("Stress"):
+        with gr.Row():
+            with gr.Column():
+                cif_stress = gr.Textbox(
+                    label="CIF Structure",
+                    placeholder="Paste CIF content here...",
+                    lines=10,
+                    value=EXAMPLE_CIF,
+                )
+                stress_btn = gr.Button("Predict Stress", variant="primary")
+            with gr.Column():
+                stress_output = gr.JSON(label="Result")
+        stress_btn.click(predict_stress, inputs=cif_stress, outputs=stress_output)
+
+    with gr.Tab("All Properties"):
+        with gr.Row():
+            with gr.Column():
+                cif_all = gr.Textbox(
+                    label="CIF Structure",
+                    placeholder="Paste CIF content here...",
+                    lines=10,
+                    value=EXAMPLE_CIF,
+                )
+                all_btn = gr.Button("Predict All", variant="primary")
+            with gr.Column():
+                all_output = gr.JSON(label="Result")
+        all_btn.click(predict_all, inputs=cif_all, outputs=all_output)
+
+    with gr.Tab("Info"):
+        info_btn = gr.Button("Get Model Info")
+        info_output = gr.JSON()
+        info_btn.click(model_info, outputs=info_output)
+
+        health_btn = gr.Button("Health Check")
+        health_output = gr.JSON()
+        health_btn.click(health_check, outputs=health_output)
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)