iints-sdk-python35 0.0.18__py3-none-any.whl

iints/core/__init__.py

@@ -0,0 +1 @@
+# Core module initialization

iints/core/algorithms/battle_runner.py

@@ -0,0 +1,138 @@
+import pandas as pd
+from typing import List, Dict, Any, Optional, Tuple
+
+from iints.core.simulator import Simulator, StressEvent
+from iints.analysis.clinical_metrics import ClinicalMetricsCalculator
+from iints.core.patient.models import PatientModel
+
+class BattleRunner:
+    """Runs a battle between different insulin algorithms."""
+
+    def __init__(self, algorithms: Dict[str, Any], patient_data: pd.DataFrame, stress_events: Optional[List[StressEvent]] = None, scenario_name: str = "standard"):
+        """
+        Initializes the BattleRunner.
+
+        Args:
+            algorithms: A dictionary of algorithm names to their instances.
+            patient_data: A DataFrame with 'time', 'glucose', and 'carbs' columns.
+            stress_events: An optional list of StressEvent objects to apply during simulation.
+            scenario_name: The name of the scenario being run.
+        """
+        self.algorithms = algorithms
+        self.patient_data = patient_data
+        self.metrics_calculator = ClinicalMetricsCalculator()
+        self.stress_events = stress_events if stress_events is not None else []
+        self.scenario_name = scenario_name
+
+    def run_battle(self, 
+                   isf_override: Optional[float] = None, 
+                   icr_override: Optional[float] = None) -> Tuple[Dict[str, Any], Dict[str, pd.DataFrame]]: # Modify return type
+        """
+        Runs the simulation for each algorithm and returns a battle report and detailed simulation data.
+
+        Args:
+            isf_override (Optional[float]): Override value for Insulin Sensitivity Factor.
+            icr_override (Optional[float]): Override value for Insulin-to-Carb Ratio.
+
+        Returns:
+            Tuple[Dict[str, Any], Dict[str, pd.DataFrame]]: A tuple containing:
+                - A dictionary containing the battle report.
+                - A dictionary mapping algorithm names to their full simulation results DataFrame.
+        """
+        battle_results = {}
+        detailed_simulation_data = {} # New dictionary to store full dfs
+        
+        for algo_name, algo_instance in self.algorithms.items():
+            print(f"Running simulation for {algo_name}...")
+
+            # Apply overrides if provided
+            if isf_override is not None and hasattr(algo_instance, 'set_isf'):
+                algo_instance.set_isf(isf_override)
+            if icr_override is not None and hasattr(algo_instance, 'set_icr'):
+                algo_instance.set_icr(icr_override)
+
+            initial_glucose = self.patient_data['glucose'].iloc[0]
+            patient_model = PatientModel(initial_glucose=initial_glucose)
+            
+            simulator = Simulator(patient_model=patient_model, algorithm=algo_instance, time_step=5)
+            
+            # Add predefined stress events to the simulator
+            for event in self.stress_events:
+                simulator.add_stress_event(event)
+
+            duration = self.patient_data['time'].max()
+            
+            # Existing carb events from patient_data are also added as stress events
+            # This needs careful consideration if scenario also adds carb events
+            for index, row in self.patient_data.iterrows():
+                if row['carbs'] > 0:
+                    simulator.add_stress_event(StressEvent(start_time=int(row['time']), event_type='meal', value=row['carbs']))
+            
+            # Unpack the tuple returned by simulator.run()
+            simulation_results_df, algorithm_safety_report = simulator.run(duration_minutes=duration)
+            
+            detailed_simulation_data[algo_name] = simulation_results_df # Store the full df
+            
+            glucose_series = simulation_results_df['glucose_actual_mgdl']
+            metrics = self.metrics_calculator.calculate(glucose=glucose_series, duration_hours=duration/60)
+            
+            # Calculate uncertainty score
+            uncertainty_score = simulation_results_df['uncertainty'].mean() if 'uncertainty' in simulation_results_df.columns else 0.0
+            
+            metrics_dict = metrics.to_dict()
+            metrics_dict['uncertainty_score'] = uncertainty_score
+            
+            # Add safety report metrics
+            bolus_interventions_count = algorithm_safety_report.get('bolus_interventions_count', 0)
+            metrics_dict['bolus_interventions_count'] = bolus_interventions_count
+            
+            # The existing 'safety_events_count' will now be based on the bolus_interventions_count
+            metrics_dict['safety_events_count'] = bolus_interventions_count 
+
+            battle_results[algo_name] = metrics_dict
+            
+        winner = max(battle_results, key=lambda algo: battle_results[algo]['tir_70_180'])
+        
+        report = {
+            "battle_name": "Algorithm Battle",
+            "winner": winner,
+            "scenario_name": self.scenario_name, # Add scenario name
+            "rankings": sorted(
+                [
+                    {
+                        "participant": algo_name,
+                        "overall_score": result['tir_70_180'],
+                        "tir": result['tir_70_180'],
+                        "tir_tight": result.get('tir_70_140', 0),
+                        "cv": result['cv'],
+                        "time_below_70": result['tir_below_70'],
+                        "time_above_180": result['tir_above_180'],
+                        "gmi": result['gmi'],
+                        "lbgi": result['lbgi'],
+                        "uncertainty_score": result['uncertainty_score'],
+                        "safety_events_count": result['safety_events_count'],
+                        "bolus_interventions_count": result['bolus_interventions_count'],
+                    }
+                    for algo_name, result in battle_results.items()
+                ],
+                key=lambda x: x["overall_score"],
+                reverse=True,
+            ),
+            "detailed_simulation_data": {algo_name: df.to_json() for algo_name, df in detailed_simulation_data.items()} # Convert DataFrames to JSON strings
+        }
+        
+        return report, detailed_simulation_data
+
+    def print_battle_report(self, battle_report: Dict[str, Any]):
+        """
+        Prints the battle report to the console.
+
+        Args:
+            battle_report: The battle report dictionary.
+        """
+        print("\nBATTLE REPORT")
+        print("="*70)
+        print(f"Winner: {battle_report['winner']}")
+        print("\nRankings:")
+        for rank in battle_report['rankings']:
+            print(f"- {rank['participant']}: TIR = {rank['tir']:.1f}%, CV = {rank['cv']:.1f}%, Safety Events = {rank['safety_events_count']}")

iints/core/algorithms/correction_bolus.py

@@ -0,0 +1,95 @@
+from typing import Dict, Any, Optional
+from iints.api.base_algorithm import InsulinAlgorithm, AlgorithmInput
+
+class CorrectionBolus(InsulinAlgorithm):
+    """
+    An insulin algorithm that calculates a meal bolus based on carbohydrates
+    and adds a correction bolus if current glucose is above a target.
+
+    This algorithm introduces sensitivity to current glucose levels.
+    """
+    def __init__(self, settings: Optional[Dict[str, Any]] = None):
+        super().__init__(settings)
+        # Default settings, can be overridden by 'settings' dict
+        self.default_settings = {
+            "fixed_basal_rate": 0.8,    # Units per hour
+            "carb_ratio": 10.0,         # Grams of carbs per unit of insulin
+            "insulin_sensitivity_factor": 50.0, # mg/dL per unit of insulin
+            "target_glucose": 100.0,    # mg/dL
+            "max_bolus": 10.0           # Maximum single bolus in Units
+        }
+        # Merge default settings with provided settings
+        self.settings = {**self.default_settings, **self.settings}
+
+        # Validate essential settings
+        if not all(k in self.settings for k in ["fixed_basal_rate", "carb_ratio", "insulin_sensitivity_factor", "target_glucose"]):
+            raise ValueError("CorrectionBolus algorithm requires 'fixed_basal_rate', 'carb_ratio', 'insulin_sensitivity_factor', and 'target_glucose' in settings.")
+
+    def predict_insulin(self, data: AlgorithmInput) -> Dict[str, Any]:
+        self.why_log = [] # Clear the log for this prediction cycle
+
+        basal_rate = self.settings["fixed_basal_rate"]
+        if data.basal_rate_u_per_hr is not None:
+            basal_rate = float(data.basal_rate_u_per_hr)
+        basal_rate_units_per_minute = basal_rate / 60.0
+        basal_insulin = basal_rate_units_per_minute * data.time_step
+        self._log_reason(f"Basal insulin calculated ({basal_rate} U/hr)", "basal_delivery", basal_insulin)
+
+        carb_intake = data.carb_intake
+        meal_bolus = 0.0
+        if carb_intake > 0:
+            carb_ratio = self.settings["carb_ratio"]
+            if data.icr is not None:
+                carb_ratio = float(data.icr)
+            meal_bolus = carb_intake / carb_ratio
+            self._log_reason(f"Meal bolus calculated for {carb_intake:.0f}g carbs (CR: {carb_ratio})", "meal_response", meal_bolus)
+        else:
+            self._log_reason("No meal bolus needed (no carb intake)", "meal_response", 0.0)
+
+
+        correction_bolus = 0.0
+        if data.current_glucose > self.settings["target_glucose"]:
+            glucose_deviation = data.current_glucose - self.settings["target_glucose"]
+            isf = self.settings["insulin_sensitivity_factor"]
+            if data.isf is not None:
+                isf = float(data.isf)
+            correction_bolus = glucose_deviation / isf
+            self._log_reason(f"Correction bolus calculated for high glucose (Current: {data.current_glucose:.0f}mg/dL, Target: {self.settings['target_glucose']:.0f}mg/dL, ISF: {isf})", "glucose_correction", correction_bolus)
+        else:
+            self._log_reason(f"No correction bolus needed (glucose at or below target: {self.settings['target_glucose']:.0f}mg/dL)", "glucose_correction", 0.0)
+
+
+        # Ensure total bolus does not exceed max_bolus
+        total_bolus_before_cap = meal_bolus + correction_bolus
+        if total_bolus_before_cap > self.settings["max_bolus"]:
+            original_meal_bolus = meal_bolus
+            original_correction_bolus = correction_bolus
+            
+            # Prioritize meal bolus, then cap correction bolus
+            if meal_bolus < self.settings["max_bolus"]:
+                remaining_capacity = self.settings["max_bolus"] - meal_bolus
+                correction_bolus = min(correction_bolus, remaining_capacity)
+            else:
+                meal_bolus = self.settings["max_bolus"] # Cap meal bolus too
+                correction_bolus = 0.0 # No correction if meal bolus maxed out
+            
+            self._log_reason(f"Total bolus capped at {self.settings['max_bolus']}. Original: Meal={original_meal_bolus:.2f}, Corr={original_correction_bolus:.2f}. Adjusted: Meal={meal_bolus:.2f}, Corr={correction_bolus:.2f}.", "safety_constraint", self.settings['max_bolus'])
+
+        total_bolus = meal_bolus + correction_bolus # Recalculate after capping
+        total_insulin_delivered = basal_insulin + total_bolus
+
+        self._log_reason(f"Final total insulin delivered: {total_insulin_delivered:.2f} U (Basal: {basal_insulin:.2f}, Meal Bolus: {meal_bolus:.2f}, Correction Bolus: {correction_bolus:.2f})", "final_decision", total_insulin_delivered)
+
+        return {
+            "basal_insulin": basal_insulin,
+            "meal_bolus": meal_bolus,
+            "correction_bolus": correction_bolus,
+            "total_insulin_delivered": total_insulin_delivered
+        }
+
+    def __str__(self):
+        return (f"CorrectionBolus Algorithm:\n"
+                f"  Fixed Basal Rate: {self.settings['fixed_basal_rate']} U/hr\n"
+                f"  Carb Ratio (CR): {self.settings['carb_ratio']} g/U\n"
+                f"  Insulin Sensitivity Factor (ISF): {self.settings['insulin_sensitivity_factor']} mg/dL/U\n"
+                f"  Target Glucose: {self.settings['target_glucose']} mg/dL")

iints/core/algorithms/discovery.py

@@ -0,0 +1,92 @@
+# src/algorithm/discovery.py
+
+import os
+import importlib
+import inspect
+from pathlib import Path
+from typing import Dict, Type
+
+from iints.api.base_algorithm import InsulinAlgorithm
+
+def discover_algorithms() -> Dict[str, Type[InsulinAlgorithm]]:
+    """
+    Dynamically discovers and loads all algorithm classes that inherit from InsulinAlgorithm.
+
+    It scans the `src/algorithm` directory and its subdirectories (like `user`).
+
+    Returns:
+        A dictionary mapping the algorithm's display name to its class type.
+        e.g., {"PID Controller": PIDController, "My Custom Algo": MyCustomAlgo}
+    """
+    algorithms: Dict[str, Type[InsulinAlgorithm]] = {}
+    
+    # The root directory for algorithm discovery
+    # We start from 'src' to make the imports work correctly (e.g., src.algorithm.pid_controller)
+    root_path = Path(__file__).parent.parent.parent # Corrected to point to project root
+    algorithm_dir = Path(__file__).parent
+    
+    for root, _, files in os.walk(algorithm_dir):
+        for filename in files:
+            # Consider only Python files, excluding __init__ and base files
+            if filename.endswith(".py") and not filename.startswith(("_", "base_")):
+                
+                # Construct the module path for importlib
+                # e.g., /path/to/project/src/algorithm/user/my_algo.py
+                # becomes -> src.algorithm.user.my_algo
+                
+                module_path = Path(root) / filename
+                # Get relative path from the 'src' directory
+                relative_path = module_path.relative_to(root_path)
+                # Convert path to module name (e.g., algorithm/user/my_algo.py -> algorithm.user.my_algo)
+                module_name = str(relative_path).replace(os.sep, '.')[:-3]
+
+                try:
+                    module = importlib.import_module(module_name)
+                    
+                    # Find all classes in the module that are subclasses of InsulinAlgorithm
+                    for _, member_class in inspect.getmembers(module, inspect.isclass):
+                        # Ensure the class is defined in this module (not imported)
+                        # and is a subclass of InsulinAlgorithm (but not the base class itself)
+                        if (
+                            issubclass(member_class, InsulinAlgorithm) 
+                            and member_class is not InsulinAlgorithm
+                            and member_class.__module__ == module_name
+                        ):
+                            # Instantiate the class to get its metadata
+                            try:
+                                instance = member_class()
+                                metadata = instance.get_algorithm_metadata()
+                                display_name = metadata.name
+                                
+                                # Avoid overwriting algorithms with the same display name
+                                if display_name in algorithms:
+                                    print(f"Warning: Duplicate algorithm name '{display_name}' found. Skipping {member_class.__name__}.")
+                                else:
+                                    algorithms[display_name] = member_class
+                            except Exception as e:
+                                print(f"Warning: Could not instantiate or get metadata for {member_class.__name__}. Error: {e}")
+                
+                except ImportError as e:
+                    print(f"Warning: Could not import module {module_name}. Error: {e}")
+
+    return algorithms
+
+if __name__ == '__main__':
+    # A simple test to demonstrate the discovery mechanism
+    print("Discovering all available IINTS-AF algorithms...")
+    discovered_algos = discover_algorithms()
+    
+    if not discovered_algos:
+        print("No algorithms found.")
+    else:
+        print("\nFound the following algorithms:")
+        for name, algo_class in discovered_algos.items():
+            print(f"- '{name}' (Class: {algo_class.__name__})")
+    
+    # Example of instantiating and using a discovered algorithm
+    if "Template Algorithm" in discovered_algos:
+        print("\n--- Testing 'Template Algorithm' ---")
+        TemplateAlgoClass = discovered_algos["Template Algorithm"]
+        template_instance = TemplateAlgoClass()
+        metadata = template_instance.get_algorithm_metadata()
+        print(f"Successfully instantiated. Author: {metadata.author}")

iints/core/algorithms/fixed_basal_bolus.py

@@ -0,0 +1,58 @@
+from typing import Dict, Any, Optional
+from iints.api.base_algorithm import InsulinAlgorithm, AlgorithmInput
+
+class FixedBasalBolus(InsulinAlgorithm):
+    """
+    A simple insulin algorithm that delivers a fixed basal rate and
+    a meal bolus based on carbohydrate intake.
+
+    This algorithm is purely rule-based and stateless (or nearly so) for transparency.
+    """
+    def __init__(self, settings: Optional[Dict[str, Any]] = None):
+        super().__init__(settings)
+        # Default settings, can be overridden by 'settings' dict
+        self.default_settings = {
+            "fixed_basal_rate": 0.8,  # Units per hour
+            "carb_ratio": 10.0,       # Grams of carbs per unit of insulin
+        }
+        # Merge default settings with provided settings
+        self.settings = {**self.default_settings, **self.settings}
+
+        # Validate essential settings
+        if not all(k in self.settings for k in ["fixed_basal_rate", "carb_ratio"]):
+            raise ValueError("FixedBasalBolus algorithm requires 'fixed_basal_rate' and 'carb_ratio' in settings.")
+
+    def predict_insulin(self, data: AlgorithmInput) -> Dict[str, Any]:
+        """
+        Calculates insulin dose based on fixed basal rate and carb intake.
+
+        Args:
+            data (AlgorithmInput): Dataclass containing all input data.
+
+        Returns:
+            Dict[str, Any]: Contains 'basal_insulin' and 'bolus_insulin' for the time step.
+        """
+        basal_rate = self.settings["fixed_basal_rate"]
+        if data.basal_rate_u_per_hr is not None:
+            basal_rate = float(data.basal_rate_u_per_hr)
+        basal_rate_units_per_minute = basal_rate / 60.0
+        basal_insulin = basal_rate_units_per_minute * data.time_step
+
+        carb_intake = data.carb_intake
+        bolus_insulin = 0.0
+        if carb_intake > 0:
+            carb_ratio = self.settings["carb_ratio"]
+            if data.icr is not None:
+                carb_ratio = float(data.icr)
+            bolus_insulin = carb_intake / carb_ratio
+
+        return {
+            "basal_insulin": basal_insulin,
+            "bolus_insulin": bolus_insulin,
+            "total_insulin_delivered": basal_insulin + bolus_insulin
+        }
+
+    def __str__(self):
+        return (f"FixedBasalBolus Algorithm:\n"
+                f"  Fixed Basal Rate: {self.settings['fixed_basal_rate']} U/hr\n"
+                f"  Carb Ratio (CR): {self.settings['carb_ratio']} g/U")

iints/core/algorithms/hybrid_algorithm.py

@@ -0,0 +1,92 @@
+try:
+    import torch  # type: ignore
+    _TORCH_AVAILABLE = True
+except Exception:  # pragma: no cover - optional dependency
+    torch = None  # type: ignore
+    _TORCH_AVAILABLE = False
+import numpy as np
+from iints.api.base_algorithm import InsulinAlgorithm, AlgorithmInput
+from .lstm_algorithm import LSTMInsulinAlgorithm
+from .correction_bolus import CorrectionBolus
+
+if _TORCH_AVAILABLE:
+    class HybridInsulinAlgorithm(InsulinAlgorithm):
+        """Hybrid algorithm that switches between LSTM and rule-based based on uncertainty."""
+        
+        def __init__(self, uncertainty_threshold=0.15, mc_samples=30):
+            super().__init__()
+            self.lstm_algo = LSTMInsulinAlgorithm()
+            self.rule_algo = CorrectionBolus()
+            self.uncertainty_threshold = uncertainty_threshold
+            self.mc_samples = mc_samples
+            self.switch_count = 0
+            self.lstm_count = 0
+            
+        def calculate_uncertainty(self, data: AlgorithmInput):
+            """Calculate uncertainty using MC Dropout."""
+            if not hasattr(self.lstm_algo, 'model') or self.lstm_algo.model is None:
+                return 1.0  # High uncertainty if model not loaded
+                
+            # Use the same input format as LSTM algorithm
+            placeholder_input = [3, data.current_glucose, 72, 29, 32, 0.47, 33]
+            input_tensor = torch.tensor(placeholder_input, dtype=torch.float32).reshape(1, 1, 7)
+            
+            self.lstm_algo.model.train()  # Enable dropout
+            predictions = []
+            
+            with torch.no_grad():
+                for _ in range(self.mc_samples):
+                    pred = self.lstm_algo.model(input_tensor).item()
+                    predictions.append(pred)
+            
+            self.lstm_algo.model.eval()  # Disable dropout
+            return np.std(predictions) / (np.mean(predictions) + 1e-8)  # Coefficient of variation
+        
+        def predict_insulin(self, data: AlgorithmInput):
+            self.why_log = [] # Clear the log for this prediction cycle
+
+            uncertainty = self.calculate_uncertainty(data)
+            self._log_reason(f"Calculated uncertainty: {uncertainty:.4f}", "uncertainty_quantification", uncertainty)
+            
+            if uncertainty > self.uncertainty_threshold:
+                self.switch_count += 1
+                self._log_reason(f"Uncertainty ({uncertainty:.4f}) exceeds threshold ({self.uncertainty_threshold:.4f}). Switching to Rule-Based Algorithm.", "decision_switch", "Rule-Based")
+                insulin_output = self.rule_algo.predict_insulin(data)
+                insulin_output["uncertainty"] = uncertainty
+                # Append child algorithm's why_log to hybrid's why_log
+                self.why_log.extend(self.rule_algo.get_why_log())
+                return insulin_output
+            else:
+                self.lstm_count += 1
+                self._log_reason(f"Uncertainty ({uncertainty:.4f}) is within threshold ({self.uncertainty_threshold:.4f}). Using LSTM Algorithm.", "decision_switch", "LSTM")
+                insulin_output = self.lstm_algo.predict_insulin(data)
+                insulin_output["uncertainty"] = uncertainty
+                # Append child algorithm's why_log to hybrid's why_log
+                self.why_log.extend(self.lstm_algo.get_why_log())
+                return insulin_output
+        
+        def reset(self):
+            self.lstm_algo.reset()
+            self.rule_algo.reset()
+            self.switch_count = 0
+            self.lstm_count = 0
+        
+        def get_state(self):
+            """Get current algorithm state."""
+            return {
+                "switch_count": self.switch_count,
+                "lstm_count": self.lstm_count,
+                "lstm_usage": self.lstm_count / (self.switch_count + self.lstm_count) if (self.switch_count + self.lstm_count) > 0 else 0
+            }
+        
+        def get_stats(self):
+            total = self.switch_count + self.lstm_count
+            return {
+                "lstm_usage": self.lstm_count / total if total > 0 else 0,
+                "rule_usage": self.switch_count / total if total > 0 else 0,
+                "total_decisions": total
+            }
+else:
+    class HybridInsulinAlgorithm(InsulinAlgorithm):  # type: ignore
+        def __init__(self, *args, **kwargs):
+            raise ImportError("Torch is required for HybridInsulinAlgorithm. Install with `pip install iints[torch]`.")

iints/core/algorithms/lstm_algorithm.py

@@ -0,0 +1,138 @@
+try:
+    import torch  # type: ignore
+    import torch.nn as nn  # type: ignore
+    _TORCH_AVAILABLE = True
+except Exception:  # pragma: no cover - optional dependency
+    torch = None  # type: ignore
+    nn = None  # type: ignore
+    _TORCH_AVAILABLE = False
+import os
+import numpy as np
+from typing import Dict, Any, List, Optional
+from collections import deque
+from iints.api.base_algorithm import InsulinAlgorithm, AlgorithmInput
+from .correction_bolus import CorrectionBolus
+
+if _TORCH_AVAILABLE:
+    # Define the LSTM model with Dropout
+    class LSTMModel(nn.Module):
+        def __init__(self, input_size, hidden_size, output_size, dropout_prob=0.5):
+            super(LSTMModel, self).__init__()
+            self.hidden_size = hidden_size
+            self.lstm = nn.LSTM(input_size, hidden_size, batch_first=True)
+            self.dropout = nn.Dropout(p=dropout_prob)
+            self.fc = nn.Linear(hidden_size, output_size)
+
+        def forward(self, x):
+            # x shape: (batch_size, sequence_length, input_size)
+            lstm_out, _ = self.lstm(x)
+            # Use the output from the last time step and apply dropout
+            out = self.dropout(lstm_out[:, -1, :])
+            output = self.fc(out)
+            return output
+else:
+    class LSTMModel:  # type: ignore
+        def __init__(self, *args, **kwargs):
+            raise ImportError("Torch is required for LSTMModel. Install with `pip install iints[torch]`.")
+
+if _TORCH_AVAILABLE:
+    class LSTMInsulinAlgorithm(InsulinAlgorithm):
+        """
+        An insulin algorithm that uses a simple LSTM model with Monte Carlo Dropout
+        for uncertainty estimation. If uncertainty is high, it falls back to a rule-based
+        algorithm.
+        """
+        def __init__(self, settings: Optional[Dict[str, Any]] = None):
+            super().__init__(settings)
+            self.default_settings = {
+                "input_features": 7,
+                "hidden_size": 50,
+                "output_size": 1,
+                "dropout_prob": 0.5,
+                "model_path": os.path.join(os.path.dirname(__file__), 'trained_lstm_model.pth'),
+                "mc_samples": 50,
+                "uncertainty_threshold": 0.5, # This threshold may need tuning
+            }
+            self.settings = {**self.default_settings, **(settings or {})}
+
+            self.model = LSTMModel(
+                self.settings["input_features"],
+                self.settings["hidden_size"],
+                self.settings["output_size"],
+                self.settings["dropout_prob"]
+            )
+            
+            # Load the trained model if it exists
+            if os.path.exists(self.settings['model_path']):
+                print(f"Loading trained model from {self.settings['model_path']}")
+                self.model.load_state_dict(torch.load(self.settings['model_path'], weights_only=True))
+            else:
+                print(f"Warning: Trained model not found at {self.settings['model_path']}. LSTM will make random predictions.")
+
+            # Instantiate fallback algorithm
+            self.fallback_algo = CorrectionBolus()
+            self.reset()
+
+        def reset(self):
+            """Resets the algorithm's internal state."""
+            super().reset()
+
+        def predict_insulin(self, data: AlgorithmInput) -> Dict[str, Any]:
+            self.why_log = [] # Clear the log for this prediction cycle
+
+            placeholder_input = [3, data.current_glucose, 72, 29, 32, 0.47, 33]
+            input_tensor = torch.tensor(placeholder_input, dtype=torch.float32).reshape(1, 1, self.settings['input_features'])
+
+            self._log_reason("LSTM input tensor created", "data_preparation", input_tensor.tolist())
+
+            # --- Monte Carlo Dropout ---
+            self.model.train() # Enable dropout
+            predictions = []
+            with torch.no_grad():
+                for _ in range(self.settings['mc_samples']):
+                    pred = self.model(input_tensor).item()
+                    predictions.append(pred)
+            self.model.eval() # Disable dropout for future use if any
+
+            mc_predictions_array = np.array(predictions)
+            mean_prediction = np.mean(mc_predictions_array)
+            std_dev = np.std(mc_predictions_array)
+            self._log_reason(f"Monte Carlo Dropout predictions generated (mean: {mean_prediction:.4f}, std dev: {std_dev:.4f})", "uncertainty_quantification", {'mean': mean_prediction, 'std_dev': std_dev})
+
+
+            # --- Hybrid Safety Controller ---
+            if std_dev > self.settings['uncertainty_threshold']:
+                self._log_reason(f"High uncertainty detected ({std_dev:.3f} > {self.settings['uncertainty_threshold']}). Falling back to rule-based algorithm.", "safety_fallback", std_dev)
+                fallback_result = self.fallback_algo.predict_insulin(data)
+                fallback_result['uncertainty'] = std_dev
+                fallback_result['fallback_triggered'] = True
+                # Extend fallback algo's log
+                self.why_log.extend(self.fallback_algo.get_why_log())
+                return fallback_result
+
+            total_insulin_delivered = max(0.0, mean_prediction * 10) # Arbitrary scaling for demo
+            self._log_reason(f"LSTM prediction accepted (uncertainty: {std_dev:.4f}). Delivered insulin scaled from raw prediction.", "lstm_prediction", total_insulin_delivered)
+
+            self.state['last_prediction'] = total_insulin_delivered
+            self.state['raw_prediction'] = mean_prediction
+            self.state['uncertainty'] = std_dev
+
+            return {
+                "total_insulin_delivered": total_insulin_delivered,
+                "predicted_insulin_raw": mean_prediction,
+                "uncertainty": std_dev,
+                "fallback_triggered": False
+            }
+
+        def __str__(self):
+            return (f"Hybrid LSTM/Rule-Based Algorithm:\n"
+                    f"  Model Path: {self.settings['model_path']}\n"
+                    f"  MC Samples: {self.settings['mc_samples']}\n"
+                    f"  Uncertainty Threshold: {self.settings['uncertainty_threshold']}")
+else:
+    class LSTMInsulinAlgorithm(InsulinAlgorithm):  # type: ignore
+        def __init__(self, *args, **kwargs):
+            raise ImportError("Torch is required for LSTMInsulinAlgorithm. Install with `pip install iints[torch]`.")
+
+        def predict_insulin(self, data: AlgorithmInput) -> Dict[str, Any]:
+            raise ImportError("Torch is required for LSTMInsulinAlgorithm. Install with `pip install iints[torch]`.")