iints-sdk-python35 1.5.12__tar.gz → 1.5.14__tar.gz

{iints_sdk_python35-1.5.12/src/iints_sdk_python35.egg-info → iints_sdk_python35-1.5.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iints-sdk-python35
-Version: 1.5.12
+Version: 1.5.14
 Summary: A pre-clinical Edge-AI SDK for diabetes management validation.
 Author-email: Rune Bobbaers <rune.bobbaers@gmail.com>
 License-Expression: Apache-2.0

{iints_sdk_python35-1.5.12 → iints_sdk_python35-1.5.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "iints-sdk-python35" 
-version = "1.5.12"
+version = "1.5.14"
 authors = [
   { name="Rune Bobbaers", email="rune.bobbaers@gmail.com" },
 ]

{iints_sdk_python35-1.5.12 → iints_sdk_python35-1.5.14}/src/iints/__init__.py

@@ -11,7 +11,7 @@ except ImportError:  # pragma: no cover - Python < 3.8 fallback
 try:
     __version__ = version("iints-sdk-python35")
 except PackageNotFoundError:  # pragma: no cover - source tree fallback
-    __version__ = "1.5.12"
+    __version__ = "1.5.14"
 
 # Note to developers: this SDK is currently maintained by a single author.
 # Please report bugs via GitHub issues and feel free to contribute fixes via PRs.

{iints_sdk_python35-1.5.12 → iints_sdk_python35-1.5.14}/src/iints/analysis/clinical_benchmark.py

@@ -14,7 +14,7 @@ from rich.panel import Panel
 from rich.progress import Progress, SpinnerColumn, TextColumn
 
 # Add project root to path
-project_root = Path(__file__).parent.parent.parent
+project_root = Path(__file__).parent.parent.parent.parent
 sys.path.insert(0, str(project_root))
 
 from iints.data.adapter import DataAdapter
@@ -81,7 +81,7 @@ class ClinicalBenchmark:
         """Display benchmark results in formatted table with visualization"""
         
         # Import visualization tools
-        from tools.glucose_visualizer import GlucoseVisualizer
+        from tools.analysis.glucose_visualizer import GlucoseVisualizer
         viz = GlucoseVisualizer()
         
         # Show patient overview first

{iints_sdk_python35-1.5.12 → iints_sdk_python35-1.5.14}/src/iints/analysis/explainable_ai.py

@@ -9,13 +9,59 @@ from datetime import datetime, timedelta
 from pathlib import Path
 import numpy as np
 
+# Import the local Ollama backend
+from iints.ai.backends.ollama import OllamaBackend
+
 class ClinicalAuditTrail:
     """Explainable AI system for clinical decision transparency"""
     
     def __init__(self):
         self.audit_log = []
         self.decision_context = {}
+        self.ollama = None
+        
+    def _init_ollama(self):
+        if self.ollama is None:
+            self.ollama = OllamaBackend()
+            try:
+                self.ollama.ensure_model_ready()
+            except Exception as e:
+                print(f"Warning: Local AI not available: {e}")
+
+    def generate_ollama_insight(self, times, glucose, ffa, ketones, insulin):
+        """
+        Sends the raw physiological arrays to the local Mistral LLM via Ollama
+        for an Explainable AI clinical diagnosis.
+        """
+        self._init_ollama()
+        if not self.ollama or not self.ollama.available():
+            return "ERROR: Local Ollama AI is not running or available."
+            
+        # Format the data arrays for the LLM
+        data_summary = (
+            f"Time (min): {times[-5:]}\n"
+            f"Glucose (mg/dL): {[round(g, 1) for g in glucose[-5:]]}\n"
+            f"Insulin (U): {[round(i, 2) for i in insulin[-5:]]}\n"
+            f"FFA (mmol/L): {[round(f, 2) for f in ffa[-5:]]}\n"
+            f"Ketones (mmol/L): {[round(k, 2) for k in ketones[-5:]]}\n"
+        )
         
+        system_prompt = (
+            "You are an Explainable AI for a Type 1 Diabetes Digital Twin. "
+            "You analyze raw mathematical arrays from the simulation and provide a clinical explanation. "
+            "Explain what the math is doing to the patient. If insulin is 0, mention hepatic glucose production. "
+            "If FFA and Ketones are rising, diagnose the lipotoxicity and Diabetic Ketoacidosis (DKA). "
+            "Keep the response professional, clinical, and under 4 sentences."
+        )
+        
+        user_prompt = f"Analyze the following patient state from the last 25 minutes of the simulation:\n{data_summary}"
+        
+        try:
+            response = self.ollama.complete(system_prompt=system_prompt, user_prompt=user_prompt)
+            return response
+        except Exception as e:
+            return f"AI Generation Failed: {e}"
+
     def log_decision(self, timestamp, glucose_current, glucose_trend, insulin_decision, 
                     algorithm_confidence, safety_override=False, context=None):
         """Log AI decision with clinical reasoning"""

{iints_sdk_python35-1.5.12 → iints_sdk_python35-1.5.14}/src/iints/cli/cli.py

@@ -8501,6 +8501,10 @@ def sources(
 
 research_app = typer.Typer(help="Research pipeline: dataset preparation and quality reporting.")
 app.add_typer(research_app, name="research")
+glucose_model_app = typer.Typer(
+    help="Dedicated glucose forecasting model workflow for training and Hugging Face export."
+)
+research_app.add_typer(glucose_model_app, name="glucose-model")
 
 
 @research_app.command(name="prepare-azt1d")
@@ -9602,6 +9606,302 @@ def research_forecast_run(
     )
 
 
+@glucose_model_app.command(name="build-dataset")
+def research_glucose_model_build_dataset(
+    input_paths: Annotated[
+        List[Path],
+        typer.Option(
+            "--input",
+            "-i",
+            help="Prepared glucose dataset CSV/Parquet. Repeat for Ohio, AZT1D, simulator exports, etc.",
+        ),
+    ],
+    output_dir: Annotated[
+        Path,
+        typer.Option(help="Output folder for normalized training dataset, manifest, and config."),
+    ] = Path("models/iints-glucose-forecast-v0/dataset"),
+    labels_csv: Annotated[
+        Optional[str],
+        typer.Option(
+            "--labels",
+            help="Optional comma-separated labels matching --input order, e.g. ohio_train,sim_10k.",
+        ),
+    ] = None,
+    profile: Annotated[str, typer.Option(help="Training profile: smoke, quick, long, or paper.")] = "long",
+    output_format: Annotated[str, typer.Option(help="Dataset output format: csv or parquet.")] = "csv",
+    history_minutes: Annotated[int, typer.Option(help="Model history window in minutes.")] = 360,
+    horizon_minutes: Annotated[int, typer.Option(help="Prediction horizon in minutes.")] = 120,
+    time_step_minutes: Annotated[int, typer.Option(help="Expected CGM sample interval in minutes.")] = 5,
+) -> None:
+    """Build the dedicated IINTS glucose-forecast training pack."""
+    console = Console()
+    labels = None
+    if labels_csv:
+        labels = [item.strip() for item in labels_csv.split(",") if item.strip()]
+    try:
+        from iints.research.glucose_model import build_glucose_training_pack
+
+        pack = build_glucose_training_pack(
+            input_paths,
+            output_dir,
+            labels=labels,
+            output_format=output_format,
+            profile=profile,
+            history_minutes=history_minutes,
+            horizon_minutes=horizon_minutes,
+            time_step_minutes=time_step_minutes,
+        )
+    except Exception as exc:
+        console.print(f"[bold red]glucose-model build-dataset failed:[/bold red] {exc}")
+        raise typer.Exit(code=1)
+
+    table = Table(title="IINTS Glucose Model Training Pack")
+    table.add_column("Artifact", style="cyan")
+    table.add_column("Value", overflow="fold")
+    table.add_row("Rows", str(pack.row_count))
+    table.add_row("Subjects", str(pack.subject_count))
+    table.add_row("Sources", str(pack.source_count))
+    table.add_row("Dataset", str(pack.dataset_path))
+    table.add_row("Config", str(pack.config_path))
+    table.add_row("Manifest", str(pack.manifest_path))
+    table.add_row("Intent", str(pack.model_intent_path))
+    console.print(table)
+    console.print(
+        "[green]Next:[/green] "
+        f"iints research glucose-model train --data {pack.dataset_path} "
+        f"--config {pack.config_path} --output-dir models/iints-glucose-forecast-v0"
+    )
+
+
+@glucose_model_app.command(name="init")
+def research_glucose_model_init(
+    output_dir: Annotated[Path, typer.Option(help="Output directory for the glucose model starter files.")] = Path(
+        "models/iints-glucose-forecast-v0"
+    ),
+    profile: Annotated[str, typer.Option(help="Training profile: smoke, quick, long, or paper.")] = "long",
+    history_minutes: Annotated[int, typer.Option(help="Model history window in minutes.")] = 360,
+    horizon_minutes: Annotated[int, typer.Option(help="Prediction horizon in minutes.")] = 120,
+    time_step_minutes: Annotated[int, typer.Option(help="Expected CGM sample interval in minutes.")] = 5,
+) -> None:
+    """Create a glucose-model config and intent file without touching data."""
+    console = Console()
+    try:
+        from iints.research.glucose_model import _render_model_intent, write_glucose_model_config
+
+        output_dir.mkdir(parents=True, exist_ok=True)
+        config_path = output_dir / "glucose_model_config.yaml"
+        payload = write_glucose_model_config(
+            config_path,
+            profile=profile,
+            history_minutes=history_minutes,
+            horizon_minutes=horizon_minutes,
+            time_step_minutes=time_step_minutes,
+        )
+        intent_payload = {
+            "row_count": "pending",
+            "subject_count": "pending",
+            "source_count": "pending",
+            "history_minutes": history_minutes,
+            "horizon_minutes": horizon_minutes,
+        }
+        intent_path = output_dir / "MODEL_INTENT.md"
+        intent_path.write_text(_render_model_intent(intent_payload))
+    except Exception as exc:
+        console.print(f"[bold red]glucose-model init failed:[/bold red] {exc}")
+        raise typer.Exit(code=1)
+
+    console.print(f"[green]Config written:[/green] {config_path}")
+    console.print(f"[green]Intent written:[/green] {intent_path}")
+    console.print(f"Profile: {payload['iints_glucose_model']['profile']}")
+
+
+@glucose_model_app.command(name="train")
+def research_glucose_model_train(
+    data: Annotated[Path, typer.Option(help="Normalized glucose training dataset CSV/Parquet.")],
+    output_dir: Annotated[Path, typer.Option(help="Output directory for predictor.pt and training_report.json.")] = Path(
+        "models/iints-glucose-forecast-v0"
+    ),
+    config: Annotated[Optional[Path], typer.Option(help="Config YAML. If omitted, one is generated.")] = None,
+    profile: Annotated[str, typer.Option(help="Generated config profile: smoke, quick, long, or paper.")] = "long",
+    epochs: Annotated[Optional[int], typer.Option(help="Override training.epochs for long local runs.")] = None,
+    batch_size: Annotated[Optional[int], typer.Option(help="Override training.batch_size.")] = None,
+    learning_rate: Annotated[Optional[float], typer.Option(help="Override training.learning_rate.")] = None,
+    warm_start: Annotated[Optional[Path], typer.Option(help="Optional predictor.pt warm-start checkpoint.")] = None,
+    export_hf: Annotated[
+        bool,
+        typer.Option("--export-hf/--no-export-hf", help="Build a Hugging Face-ready folder after training."),
+    ] = True,
+    repo_id: Annotated[Optional[str], typer.Option(help="Optional Hugging Face repo id for model card hints.")] = None,
+    dataset_manifest: Annotated[Optional[Path], typer.Option(help="Optional dataset manifest for HF public metadata.")] = None,
+    comparison_dir: Annotated[
+        Optional[Path],
+        typer.Option(help="Optional glucose-model compare output directory to bundle with the Hugging Face export."),
+    ] = None,
+) -> None:
+    """Train the dedicated IINTS glucose-forecast model using the existing predictor engine."""
+    console = Console()
+    if not data.exists():
+        console.print(f"[bold red]Dataset not found: {data}[/bold red]")
+        raise typer.Exit(code=1)
+
+    try:
+        from iints.research.glucose_model import write_glucose_model_config, write_huggingface_export_bundle
+
+        output_dir.mkdir(parents=True, exist_ok=True)
+        resolved_config = output_dir / "glucose_model_config.resolved.yaml"
+        if config is None:
+            payload = write_glucose_model_config(output_dir / "glucose_model_config.yaml", profile=profile)
+        else:
+            payload = yaml.safe_load(config.read_text())
+        if epochs is not None:
+            payload.setdefault("training", {})["epochs"] = int(epochs)
+        if batch_size is not None:
+            payload.setdefault("training", {})["batch_size"] = int(batch_size)
+        if learning_rate is not None:
+            payload.setdefault("training", {})["learning_rate"] = float(learning_rate)
+        resolved_config.write_text(yaml.safe_dump(payload, sort_keys=False))
+
+        script = Path(__file__).resolve().parents[3] / "research" / "train_predictor.py"
+        cmd = [
+            sys.executable,
+            str(script),
+            "--data",
+            str(data),
+            "--config",
+            str(resolved_config),
+            "--out",
+            str(output_dir),
+        ]
+        if warm_start is not None:
+            cmd.extend(["--warm-start", str(warm_start)])
+        subprocess.run(cmd, check=True)
+        hf_outputs = None
+        if export_hf:
+            manifest = dataset_manifest
+            if manifest is None:
+                candidate = data.parent / "glucose_dataset_manifest.json"
+                manifest = candidate if candidate.exists() else None
+            hf_outputs = write_huggingface_export_bundle(
+                model_dir=output_dir,
+                output_dir=output_dir / "huggingface",
+                repo_id=repo_id,
+                dataset_manifest=manifest,
+                comparison_dir=comparison_dir,
+            )
+    except subprocess.CalledProcessError as exc:
+        console.print(f"[bold red]glucose-model train failed with exit code {exc.returncode}[/bold red]")
+        raise typer.Exit(code=exc.returncode)
+    except Exception as exc:
+        console.print(f"[bold red]glucose-model train failed:[/bold red] {exc}")
+        raise typer.Exit(code=1)
+
+    console.print(f"[green]Model written:[/green] {output_dir / 'predictor.pt'}")
+    console.print(f"[green]Training report:[/green] {output_dir / 'training_report.json'}")
+    if hf_outputs:
+        console.print(f"[green]Hugging Face bundle:[/green] {hf_outputs['output_dir']}")
+
+
+@glucose_model_app.command(name="export-hf")
+def research_glucose_model_export_hf(
+    model_dir: Annotated[Path, typer.Option(help="Directory containing predictor.pt and training_report.json.")] = Path(
+        "models/iints-glucose-forecast-v0"
+    ),
+    output_dir: Annotated[Path, typer.Option(help="Output directory for the Hugging Face-ready bundle.")] = Path(
+        "models/iints-glucose-forecast-v0/huggingface"
+    ),
+    repo_id: Annotated[Optional[str], typer.Option(help="Optional Hugging Face repo id, e.g. user/iints-glucose-forecast-v0.")] = None,
+    dataset_manifest: Annotated[Optional[Path], typer.Option(help="Optional private manifest to redact into public metadata.")] = None,
+    comparison_dir: Annotated[
+        Optional[Path],
+        typer.Option(help="Optional glucose-model compare output directory to include comparison metrics and reports."),
+    ] = None,
+) -> None:
+    """Export predictor.pt plus a research-safe Hugging Face model card."""
+    console = Console()
+    try:
+        from iints.research.glucose_model import write_huggingface_export_bundle
+
+        outputs = write_huggingface_export_bundle(
+            model_dir=model_dir,
+            output_dir=output_dir,
+            repo_id=repo_id,
+            dataset_manifest=dataset_manifest,
+            comparison_dir=comparison_dir,
+        )
+    except Exception as exc:
+        console.print(f"[bold red]glucose-model export-hf failed:[/bold red] {exc}")
+        raise typer.Exit(code=1)
+
+    table = Table(title="Hugging Face Export Bundle")
+    table.add_column("Artifact", style="cyan")
+    table.add_column("Path", overflow="fold")
+    for key, value in outputs.items():
+        table.add_row(key, value)
+    console.print(table)
+    console.print("[yellow]Recommended:[/yellow] upload private first, review README.md, then decide whether public is allowed.")
+
+
+@glucose_model_app.command(name="compare")
+def research_glucose_model_compare(
+    data: Annotated[Path, typer.Option(help="Normalized glucose dataset CSV/Parquet to evaluate on.")],
+    output_dir: Annotated[Path, typer.Option(help="Output directory for comparison reports.")] = Path(
+        "results/glucose_model_comparison"
+    ),
+    model_specs: Annotated[
+        Optional[List[str]],
+        typer.Option(
+            "--model",
+            "-m",
+            help="Model checkpoint as label=path/to/predictor.pt. Repeat for MSE/Band/PINN models.",
+        ),
+    ] = None,
+    config: Annotated[Optional[Path], typer.Option(help="Comparison config YAML. Defaults to glucose-model quick config.")] = None,
+    include_baselines: Annotated[
+        bool,
+        typer.Option("--include-baselines/--no-baselines", help="Compare transparent LastValue/LinearTrend/Physiology baselines."),
+    ] = True,
+    mc_samples: Annotated[int, typer.Option(help="MC dropout samples for checkpoint uncertainty. Use 0 to disable.")] = 0,
+    max_roc_mgdl_min: Annotated[
+        float,
+        typer.Option(help="Maximum plausible predicted glucose rate-of-change in mg/dL/min."),
+    ] = 10.0,
+) -> None:
+    """Compare MSE/Band/PINN glucose models against baselines and physiology gates."""
+    console = Console()
+    try:
+        from iints.research.glucose_model import compare_glucose_models, parse_model_specs
+
+        bundle = compare_glucose_models(
+            data_path=data,
+            output_dir=output_dir,
+            model_specs=parse_model_specs(model_specs or []),
+            config_path=config,
+            include_baselines=include_baselines,
+            mc_samples=mc_samples,
+            max_roc_mgdl_min=max_roc_mgdl_min,
+        )
+    except Exception as exc:
+        console.print(f"[bold red]glucose-model compare failed:[/bold red] {exc}")
+        raise typer.Exit(code=1)
+
+    table = Table(title="IINTS Glucose Model Comparison")
+    table.add_column("Artifact", style="cyan")
+    table.add_column("Path / Value", overflow="fold")
+    table.add_row("Rows", str(bundle.row_count))
+    table.add_row("Models", str(bundle.model_count))
+    table.add_row("Report JSON", str(bundle.report_json))
+    table.add_row("Report Markdown", str(bundle.report_md))
+    table.add_row("Horizon metrics", str(bundle.horizon_metrics_csv))
+    table.add_row("Physiology violations", str(bundle.physiological_violations_csv))
+    table.add_row("Hypo detection", str(bundle.hypo_detection_csv))
+    table.add_row("Model-card metrics", str(bundle.model_card_metrics_json))
+    console.print(table)
+    console.print(
+        "[yellow]Promotion rule:[/yellow] do not promote a model just because MAE improves; "
+        "also inspect missed hypo rate, uncertainty, and physiological violations."
+    )
+
+
 @research_app.command(name="parity-check")
 def research_parity_check(
     model: Annotated[Path, typer.Option(help="Predictor checkpoint (.pt)")],

{iints_sdk_python35-1.5.12 → iints_sdk_python35-1.5.14}/src/iints/core/algorithms/pid_controller.py

@@ -40,7 +40,15 @@ class PIDController(InsulinAlgorithm):
         self._log_reason("Derivative term calculated", "control_parameter", derivative)
 
         # Integral term (accumulated error) with anti-windup protection
-        proposed_integral = max(-self.integral_limit, min(self.integral + error, self.integral_limit))
+        # SCIENTIFIC UPGRADE: Pharmacokinetic (PK) Feed-Forward Integration
+        # We dynamically drain the integral windup based on the actual Insulin On Board (mass balance).
+        pk_feed_forward_inhibition = data.insulin_on_board * 2.0  # Tuning parameter for PK dampening
+        
+        proposed_integral = max(
+            -self.integral_limit, 
+            min(self.integral + error - pk_feed_forward_inhibition, self.integral_limit)
+        )
+        
         unsaturated_output = (
             self.kp * error
             + self.ki * proposed_integral
@@ -56,7 +64,7 @@ class PIDController(InsulinAlgorithm):
             )
         else:
             self.integral = proposed_integral
-            self._log_reason("Integral term updated", "control_parameter", self.integral)
+            self._log_reason(f"Integral term updated (dampened by {pk_feed_forward_inhibition:.2f} due to {data.insulin_on_board:.1f}U IOB)", "control_parameter", self.integral)
         
         # PID formula
         insulin_dose = (self.kp * error + 

{iints_sdk_python35-1.5.12 → iints_sdk_python35-1.5.14}/src/iints/core/devices/models.py

@@ -22,12 +22,12 @@ class SensorModel:
 
     def __init__(
         self,
-        noise_std: float = 0.0,
+        noise_std: float = 8.5,
         bias: float = 0.0,
-        lag_minutes: int = 0,
+        lag_minutes: int = 5,
         isf_tau_minutes: float = 5.0,
         noise_ar1_phi: float = 0.85,
-        noise_fbm_hurst: Optional[float] = None,
+        noise_fbm_hurst: Optional[float] = 0.78,
         dropout_prob: float = 0.0,
         seed: Optional[int] = None,
         drift_std_per_hour: float = 0.0,
@@ -393,9 +393,28 @@ class PumpModel:
             reason = f"max_units_per_step {self.max_units_per_step:.2f}"
 
         if self.quantization_units:
-            delivered = round(delivered / self.quantization_units) * self.quantization_units
-
-        if self.delivery_noise_std > 0:
+            # SCIENTIFIC UPGRADE: discrete micro-stepper quantization.
+            # The pump delivers integer motor steps; optional noise is modeled as
+            # missed or extra steps instead of continuous Gaussian dose drift.
+            micro_steps = round(delivered / self.quantization_units)
+            
+            if self.delivery_noise_std > 0:
+                # Instead of adding Gaussian noise, we simulate physical rotor slip per micro-step.
+                slip_prob = min(0.15, self.delivery_noise_std)  # Convert abstract std into slip probability
+                actual_steps = micro_steps
+                for _ in range(int(micro_steps)):
+                    if float(self._rng.random()) < slip_prob:
+                        # 70% chance to miss a step (friction/backlash), 30% chance to double-step (momentum)
+                        if float(self._rng.random()) < 0.7:
+                            actual_steps -= 1
+                        else:
+                            actual_steps += 1
+                micro_steps = max(0, actual_steps)
+                
+            delivered = micro_steps * self.quantization_units
+            delivered = max(0.0, delivered)
+        elif self.delivery_noise_std > 0:
+            # Fallback for continuous infusion models without quantization
             delivered += float(self._rng.normal(0, self.delivery_noise_std))
             delivered = max(0.0, delivered)
 

{iints_sdk_python35-1.5.12 → iints_sdk_python35-1.5.14}/src/iints/core/patient/__init__.py

@@ -3,7 +3,9 @@ from .models import PatientModel
 
 try:
     from .bergman_model import BergmanPatientModel
+    from .advanced_metabolic_model import AdvancedMetabolicModel
 except ImportError:  # pragma: no cover - scipy may not be installed
     BergmanPatientModel = None  # type: ignore[assignment,misc]
+    AdvancedMetabolicModel = None  # type: ignore[assignment,misc]
 
-__all__ = ["PatientProfile", "PatientModel", "BergmanPatientModel"]
+__all__ = ["PatientProfile", "PatientModel", "BergmanPatientModel", "AdvancedMetabolicModel"]