autoemulate 0.3.2__tar.gz → 0.4.0__tar.gz

{autoemulate-0.3.2 → autoemulate-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: autoemulate
-Version: 0.3.2
+Version: 0.4.0
 Summary: A python package for semi-automated emulation
 License: MIT
 Author: AutoEmulate contributors (see our GitHub page)
@@ -12,6 +12,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: docs
 Requires-Dist: anytree (>=2.12.1,<3.0.0)
+Requires-Dist: corner (>=2.2.3,<3.0.0)
 Requires-Dist: gpytorch (>=1.12,<2.0)
 Requires-Dist: iprogress (>=0.4,<0.5)
 Requires-Dist: ipywidgets (>=8.1.2,<9.0.0)
@@ -21,6 +22,7 @@ Requires-Dist: matplotlib (>=3.7.2,<4.0.0)
 Requires-Dist: mogp-emulator (>=0.7.2,<0.8.0)
 Requires-Dist: numpy (>=1.24,<2.0)
 Requires-Dist: pandas (>=2.1,<3.0)
+Requires-Dist: pyro-ppl (>=1.9.1,<2.0.0)
 Requires-Dist: salib (>=1.5.1,<2.0.0)
 Requires-Dist: scikit-learn (>=1.3.0,<1.6.0)
 Requires-Dist: scipy (>=1.11.3,<2.0.0)
@@ -41,7 +43,7 @@ Description-Content-Type: text/markdown
 [![Documentation](https://img.shields.io/badge/documentation-blue)](https://alan-turing-institute.github.io/autoemulate/)
 
 <!-- SPHINX-START -->
-Simulations of physical systems are often slow and need lots of compute, which makes them unpractical for real-world applications like digital twins, or when they have to run thousands of times for sensitivity analyses. The goal of `AutoEmulate` is to make it easy to replace simulations with fast, accurate emulators. To do this, `AutoEmulate` automatically fits and compares various emulators, ranging from simple models like Radial Basis Functions and Second Order Polynomials to more complex models like Support Vector Machines, Gaussian Processes and Conditional Neural Processes to find the best emulator for a simulation. 
+Simulations of physical systems are often slow and need lots of compute, which makes them unpractical for real-world applications like digital twins, or when they have to run thousands of times for sensitivity analyses. The goal of `AutoEmulate` is to make it easy to replace simulations with fast, accurate emulators. To do this, `AutoEmulate` automatically fits and compares various emulators, ranging from simple models like Radial Basis Functions and Second Order Polynomials to more complex models like Support Vector Machines and  Gaussian Processes to find the best emulator for a simulation. 
 
 ⚠️ Warning: This is an early version of the package and is still under development. We are working on improving the documentation and adding more features. If you have any questions or suggestions, please open an issue or a pull request.
 

{autoemulate-0.3.2 → autoemulate-0.4.0}/README.md

@@ -7,7 +7,7 @@
 [![Documentation](https://img.shields.io/badge/documentation-blue)](https://alan-turing-institute.github.io/autoemulate/)
 
 <!-- SPHINX-START -->
-Simulations of physical systems are often slow and need lots of compute, which makes them unpractical for real-world applications like digital twins, or when they have to run thousands of times for sensitivity analyses. The goal of `AutoEmulate` is to make it easy to replace simulations with fast, accurate emulators. To do this, `AutoEmulate` automatically fits and compares various emulators, ranging from simple models like Radial Basis Functions and Second Order Polynomials to more complex models like Support Vector Machines, Gaussian Processes and Conditional Neural Processes to find the best emulator for a simulation. 
+Simulations of physical systems are often slow and need lots of compute, which makes them unpractical for real-world applications like digital twins, or when they have to run thousands of times for sensitivity analyses. The goal of `AutoEmulate` is to make it easy to replace simulations with fast, accurate emulators. To do this, `AutoEmulate` automatically fits and compares various emulators, ranging from simple models like Radial Basis Functions and Second Order Polynomials to more complex models like Support Vector Machines and  Gaussian Processes to find the best emulator for a simulation. 
 
 ⚠️ Warning: This is an early version of the package and is still under development. We are working on improving the documentation and adding more features. If you have any questions or suggestions, please open an issue or a pull request.
 

{autoemulate-0.3.2 → autoemulate-0.4.0}/autoemulate/compare.py

@@ -986,8 +986,6 @@ class AutoEmulate:
         problem=None,
         N=1024,
         conf_level=0.95,
-        as_df=True,
-        **plot_kwargs,
     ):
         """Perform Sobol sensitivity analysis on a fitted emulator.
 
@@ -1024,23 +1022,15 @@ class AutoEmulate:
         conf_level : float, optional
             Confidence level (between 0 and 1) for calculating confidence intervals of the
             sensitivity indices. Default is 0.95 (95% confidence).
-        as_df : bool, optional
-            If True, returns results as a long-format pandas DataFrame with columns for
-            parameters, sensitivity indices, and confidence intervals. If False, returns
-            the raw SALib results dictionary. Default is True.
 
         Returns
         -------
-        pandas.DataFrame or dict
-            If as_df=True (default), returns a DataFrame with columns:
-
+        pandas.DataFrame
             - 'parameter': Input parameter name
             - 'output': Output variable name
             - 'S1', 'S2', 'ST': First, second, and total order sensitivity indices
             - 'S1_conf', 'S2_conf', 'ST_conf': Confidence intervals for each index
 
-            If as_df=False, returns the raw SALib results dictionary.
-
         Notes
         -----
         The analysis requires N * (2D + 2) model evaluations, where D is the number of input
@@ -1065,7 +1055,6 @@ class AutoEmulate:
             X=self.X,
             N=N,
             conf_level=conf_level,
-            as_df=as_df,
         )
 
         return df_results

{autoemulate-0.3.2 → autoemulate-0.4.0}/autoemulate/emulators/__init__.py

@@ -1,8 +1,5 @@
 from ..model_registry import ModelRegistry
-from .conditional_neural_process import ConditionalNeuralProcess
-from .conditional_neural_process_attn import AttentiveConditionalNeuralProcess
 from .gaussian_process import GaussianProcess
-from .gaussian_process_mogp import GaussianProcessMOGP
 from .gaussian_process_mt import GaussianProcessMT
 from .gaussian_process_sklearn import GaussianProcessSklearn
 from .gradient_boosting import GradientBoosting
@@ -33,17 +30,8 @@ model_registry.register_model(
 model_registry.register_model(
     GaussianProcess().model_name, GaussianProcess, is_core=True
 )
-model_registry.register_model(
-    ConditionalNeuralProcess().model_name, ConditionalNeuralProcess, is_core=True
-)
-
 
 # non-core models
-model_registry.register_model(
-    AttentiveConditionalNeuralProcess().model_name,
-    AttentiveConditionalNeuralProcess,
-    is_core=False,
-)
 model_registry.register_model(
     GaussianProcessMT().model_name, GaussianProcessMT, is_core=False
 )

{autoemulate-0.3.2 → autoemulate-0.4.0}/autoemulate/experimental/data/utils.py

@@ -29,11 +29,11 @@ class ConversionMixin:
         if isinstance(y, np.ndarray):
             y = torch.tensor(y, dtype=torch.float32)
 
-        if isinstance(x, (torch.Tensor, np.ndarray)) and isinstance(
-            y, (torch.Tensor, np.ndarray)
+        if isinstance(x, torch.Tensor | np.ndarray) and isinstance(
+            y, torch.Tensor | np.ndarray
         ):
             dataset = TensorDataset(x, y)
-        elif isinstance(x, (torch.Tensor, np.ndarray)) and y is None:
+        elif isinstance(x, torch.Tensor | np.ndarray) and y is None:
             dataset = TensorDataset(x)
         elif isinstance(x, Dataset) and y is None:
             dataset = x

autoemulate-0.4.0/autoemulate/experimental/emulators/gradient_boosting.py

@@ -0,0 +1,80 @@
+from typing import Literal
+
+import numpy as np
+from scipy.stats import loguniform
+from sklearn.ensemble import GradientBoostingRegressor
+
+from autoemulate.experimental.device import TorchDeviceMixin
+from autoemulate.experimental.emulators.base import SklearnBackend
+from autoemulate.experimental.types import DeviceLike, TensorLike
+
+
+class GradientBoosting(SklearnBackend):
+    """Gradient Boosting Emulator.
+
+    Wraps Gradient Boosting regression from scikit-learn.
+    """
+
+    def __init__(  # noqa: PLR0913 allow too many arguments since all currently required
+        self,
+        x: TensorLike,
+        y: TensorLike,
+        loss: Literal[
+            "squared_error", "absolute_error", "huber", "quantile"
+        ] = "squared_error",
+        learning_rate: float = 0.1,
+        n_estimators: int = 100,
+        max_depth: int = 3,
+        min_samples_split: int = 2,
+        min_samples_leaf: int = 1,
+        subsample: float = 1.0,
+        max_features: float | None = None,
+        ccp_alpha: float = 0.0,
+        n_iter_no_change: int | None = None,
+        random_seed: int | None = None,
+        device: DeviceLike = "cpu",
+    ):
+        """Initializes a GradientBoosting object."""
+        _, _ = x, y  # ignore unused arguments
+        TorchDeviceMixin.__init__(self, device=device, cpu_only=True)
+        self.loss = loss
+        self.learning_rate = learning_rate
+        self.n_estimators = n_estimators
+        self.max_depth = max_depth
+        self.min_samples_split = min_samples_split
+        self.min_samples_leaf = min_samples_leaf
+        self.subsample = subsample
+        self.max_features = max_features
+        self.ccp_alpha = ccp_alpha
+        self.n_iter_no_change = n_iter_no_change
+        self.random_seed = random_seed
+        self.model = GradientBoostingRegressor(
+            loss=self.loss,
+            learning_rate=self.learning_rate,
+            n_estimators=self.n_estimators,
+            max_depth=self.max_depth,
+            min_samples_split=self.min_samples_split,
+            min_samples_leaf=self.min_samples_leaf,
+            subsample=self.subsample,
+            max_features=self.max_features,
+            ccp_alpha=self.ccp_alpha,
+            n_iter_no_change=self.n_iter_no_change,
+            random_state=self.random_seed,
+        )
+
+    @staticmethod
+    def is_multioutput() -> bool:
+        return False
+
+    @staticmethod
+    def get_tune_config():
+        return {
+            "learning_rate": [loguniform(0.01, 0.2).rvs()],
+            "n_estimators": [np.random.randint(100, 500)],
+            "max_depth": [np.random.randint(3, 8)],
+            "min_samples_split": [np.random.randint(2, 20)],
+            "min_samples_leaf": [np.random.randint(1, 6)],
+            "subsample": [np.random.uniform(0.6, 1.0)],
+            "max_features": ["sqrt", "log2", None],
+            "ccp_alpha": [loguniform(0.001, 0.1).rvs()],
+        }

{autoemulate-0.3.2 → autoemulate-0.4.0}/autoemulate/experimental/emulators/lightgbm.py

@@ -104,7 +104,7 @@ class LightGBM(Emulator):
     def _predict(self, x: TensorLike) -> OutputLike:
         """Predicts the output of the emulator for a given input."""
         y_pred = self.model_.predict(x)
-        assert not isinstance(y_pred, (spmatrix, list))
+        assert not isinstance(y_pred, spmatrix | list)
         _, y = self._convert_to_tensors(x, y_pred)
         return y
 

{autoemulate-0.3.2 → autoemulate-0.4.0}/autoemulate/experimental/emulators/neural_processes/conditional_neural_process.py

@@ -105,7 +105,7 @@ def cnp_collate_fn(batch, device: DeviceLike | None = None):
     as we don't do layernorm or attention, but we should modify cnp etc. to handle this
     better.
     """
-    X, y = zip(*batch)
+    X, y = zip(*batch, strict=False)
     device = get_torch_device(device)
 
     # Get the maximum number of context and target points in the batch
@@ -123,7 +123,7 @@ def cnp_collate_fn(batch, device: DeviceLike | None = None):
     target_mask = torch.zeros(len(batch), max_target, dtype=torch.bool)
 
     # Fill in the batched tensors
-    for i, (x, yi) in enumerate(zip(X, y)):
+    for i, (x, yi) in enumerate(zip(X, y, strict=False)):
         n_context = x["x_context"].shape[0]
         n_target = x["x_target"].shape[0]
 

autoemulate-0.4.0/autoemulate/experimental/exploratory/hm_refactor.ipynb

@@ -0,0 +1,454 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Refactored HistoryMatching workflow example\n",
+    "\n",
+    "## 1. Set up"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "\n",
+    "# imports from main\n",
+    "from autoemulate.history_matching_dashboard import HistoryMatchingDashboard\n",
+    "\n",
+    "# imports from experimental\n",
+    "from autoemulate.experimental.emulators.gaussian_process.exact import (\n",
+    "    GaussianProcessExact,\n",
+    ")\n",
+    "from autoemulate.experimental.simulations.epidemic import Epidemic\n",
+    "from autoemulate.experimental.history_matching import HistoryMatching, HistoryMatchingWorkflow"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Simulate data & train a GP\n",
+    "\n",
+    "Set up a `Simulator` and generate data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Running simulations: 100%|██████████| 10/10 [00:00<00:00, 553.21it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Successfully completed 10/10 simulations (100.0%)\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "simulator = Epidemic()\n",
+    "x = simulator.sample_inputs(10)\n",
+    "y = simulator.forward_batch(x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The next step should be done with `AutoEmulate.compare()`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gp = GaussianProcessExact(x, y)\n",
+    "gp.fit(x, y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. HistoryMatching\n",
+    "\n",
+    "Firstly, one can instantiate `HistoryMatching` without a simulator or an emulator. It can be used to calculate implausability for a given set of predictions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/bj/kdwy1bhj3h728lr5xdj19yd40000gr/T/ipykernel_13433/4021603184.py:3: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  output = gp.predict(torch.tensor(x_new, dtype=torch.float32))\n"
+     ]
+    }
+   ],
+   "source": [
+    "# generate predictions for new x inputs\n",
+    "x_new = simulator.sample_inputs(10)\n",
+    "output = gp.predict(torch.tensor(x_new, dtype=torch.float32))\n",
+    "pred_means, pred_vars = (\n",
+    "    output.mean.float().detach(),\n",
+    "    output.variance.float().detach(),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define observed data with means and variances\n",
+    "observations = {\"infection_rate\": (0.3, 0.05)}\n",
+    "\n",
+    "# Create history matcher\n",
+    "hm = HistoryMatching(\n",
+    "    observations=observations,\n",
+    "    threshold=3.0\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "implausability = hm.calculate_implausibility(pred_means, pred_vars)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Once implausability has been calculated, it can be used to identify indices of NROY parameters:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "hm.get_nroy(implausability)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Or to filter parameters at those NROY indices:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([[0.1709, 0.0508],\n",
+       "        [0.4401, 0.0828],\n",
+       "        [0.3762, 0.0232],\n",
+       "        [0.1998, 0.1910],\n",
+       "        [0.3041, 0.1451],\n",
+       "        [0.2680, 0.0296],\n",
+       "        [0.4938, 0.1741],\n",
+       "        [0.2367, 0.0964],\n",
+       "        [0.1025, 0.1294],\n",
+       "        [0.3978, 0.1181]])"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\n",
+    "hm.get_nroy(implausability, x_new)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Optionally, `HistoryMatching` can be instantiated with an emulator to make extracting prediction means and variances easier."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([[0.0526],\n",
+       "        [0.0409],\n",
+       "        [0.0536],\n",
+       "        [0.0313],\n",
+       "        [0.0283],\n",
+       "        [0.0547],\n",
+       "        [0.0281],\n",
+       "        [0.0363],\n",
+       "        [0.0300],\n",
+       "        [0.0315]])"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "hm_with_emul = HistoryMatching(\n",
+    "    observations=observations,\n",
+    "    threshold=3.0,\n",
+    "    emulator=gp\n",
+    ")\n",
+    "\n",
+    "pred_means, pred_vars = hm_with_emul.emulator_predict(x_new)\n",
+    "hm_with_emul.calculate_implausibility(pred_means, pred_vars)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Iterative HistoryMatchingWorkflow\n",
+    "\n",
+    "We also have a separate class that implements an iterative sample-predict-refit workflow:\n",
+    "- sample `n_test_samples` to test from the NROY space\n",
+    "- use emulator to filter out implausible samples and update the NROY space\n",
+    "- run `n_simulations` predictions for the sampled parameters using the simulator\n",
+    "- refit the emulator using the simulated data\n",
+    "\n",
+    "The object maintains and updates the internal state each time `run()` is called so this can be done as many times as the user wants."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Running simulations: 100%|██████████| 20/20 [00:00<00:00, 1140.05it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Successfully completed 20/20 simulations (100.0%)\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "hmw = HistoryMatchingWorkflow(\n",
+    "    simulator=simulator,\n",
+    "    emulator=gp,\n",
+    "    observations=observations,\n",
+    "    threshold=3.0,\n",
+    "    train_x=x,\n",
+    "    train_y=y\n",
+    ")\n",
+    "\n",
+    "test_parameters, impl_scores = hmw.run(n_simulations=20, n_test_samples=100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(torch.Size([100, 2]), torch.Size([100, 1]))"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "test_parameters.shape, impl_scores.shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can call `run()` as many times as we want, the class stores states from previous runs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Running simulations: 100%|██████████| 20/20 [00:00<00:00, 1008.67it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Successfully completed 20/20 simulations (100.0%)\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_parameters, impl_scores = hmw.run(n_simulations=20, n_test_samples=100)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Integration with dashboard"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dashboard = HistoryMatchingDashboard(\n",
+    "    samples=test_parameters,\n",
+    "    impl_scores=impl_scores,\n",
+    "    param_names=simulator.param_names,  \n",
+    "    output_names=simulator.output_names, \n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c0a1f4ff869a4acf86ed20bf20689055",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HTML(value='<h2>History Matching Dashboard</h2>')"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f83c37cf211246d6a8753961a7c02639",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HBox(children=(Dropdown(description='Plot Type:', options=('Parameter vs Implausibility', 'Pair…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "dashboard.display()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}