{ "cells": [ { "cell_type": "markdown", "id": "1ad9942c", "metadata": {}, "source": [ "# How to build your own time series model/dataset?\n", "\n", "In this tutorial, we will show how to build a model or dataset for benchmarking from scratch." ] }, { "cell_type": "markdown", "id": "626ae316", "metadata": {}, "source": [ "## Unconditional Case\n", "### 1. Base Model class\n", "To join `GenTS` model zoo, your model should inherit `BaseModel` class, implementing:\n", "- `ALLOW_CONDITION`: class attribute, indicating the allowed condition types (`predict`, `impute`, `class`, `None`)\n", "- `__init__`: initialization function. The must-have arguments include `seq_len`(int, the length of time series sequence), `seq_dim`(int, the dimension of time series sequence), `condition`(str, the condition type, choose from `ALLOW_CONDITION`)\n", "- `_sample_impl(self, n_sample, condition=None, **kwargs)`: sampling logic, indicating how to sample a time series after training.\n", "- `training_step(self, batch, batch_idx)`: training step logic\n", "- `validation_step(self, batch, batch_idx)`: validation step logic, optional\n", "- `configure_optimizers`: config optimizer(s).\n", "\n", "Essentially, `BaseModel` roots from `lightning.LightningModule`, therefore `training_step`, `validation_step`, and `configure_optimizers` are from `LightningModule`. Please check [our API documents](https://willwang1113.github.io/GenTS/api_doc/modules.html) or [this website](https://lightning.ai/docs/pytorch/stable/common/lightning_module.html) for details.\n", "\n", "For example, we will show how to customize a VAE model with MLP backbone." ] }, { "cell_type": "code", "execution_count": 1, "id": "b59d5fd1", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/wcx/anaconda3/envs/gents/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", " from .autonotebook import tqdm as notebook_tqdm\n", "CUDA extension for cauchy multiplication not found. Install by going to extensions/cauchy/ and running `python setup.py install`. This should speed up end-to-end training by 10-50%\n", "Falling back on slow Cauchy kernel. Install at least one of pykeops or the CUDA extension for efficiency.\n", "Falling back on slow Vandermonde kernel. Install pykeops for improved memory efficiency.\n" ] } ], "source": [ "import torch\n", "from gents.model.base import BaseModel\n", "from torchvision.ops import MLP\n", "from torch.nn import functional as F\n", "\n", "\n", "def kl_loss(z_post_mean, z_post_logvar, z_prior_mean, z_prior_logvar):\n", " # COMPUTE KL DIV\n", " z_post_var = torch.exp(z_post_logvar)\n", " z_prior_var = torch.exp(z_prior_logvar)\n", " kld_z = 0.5 * (\n", " z_prior_logvar\n", " - z_post_logvar\n", " + ((z_post_var + torch.pow(z_post_mean - z_prior_mean, 2)) / z_prior_var)\n", " - 1\n", " )\n", " return kld_z\n", "\n", "class MyVAE(BaseModel):\n", " # We show unconditional vae as a simple example\n", " ALLOW_CONDITION = [None]\n", "\n", " def __init__(self, seq_len, seq_dim, latent_dim, condition, **kwargs):\n", " super().__init__(seq_len, seq_dim, condition, **kwargs)\n", " self.w_kl = 1e-3 # weight for KL loss\n", " self.seq_len = seq_len\n", " self.seq_dim = seq_dim\n", " self.latent_dim = latent_dim\n", "\n", " # Define encoder and decoder networks\n", " self.encoder = MLP(seq_dim * seq_len, [256, 256, latent_dim])\n", " self.decoder = MLP(latent_dim, [256, 256, seq_dim * seq_len])\n", "\n", " # z network\n", " self.fc_mu = MLP(latent_dim, [latent_dim])\n", " self.fc_logvar = MLP(latent_dim, [latent_dim])\n", "\n", " def _sample_impl(self, n_sample=1, condition=None, **kwargs):\n", " z = torch.randn((n_sample, self.latent_dim)).to(self.device)\n", " all_samples = self.decoder(z).reshape(n_sample, self.seq_len, self.seq_dim)\n", " return all_samples\n", "\n", " def training_step(self, batch, batch_idx):\n", " ##################################################\n", " # See next code block on what we have in a batch #\n", " ##################################################\n", " x = batch[\"seq\"].flatten(1)\n", " \n", " # encode\n", " latents = self.encoder(x)\n", " mu = self.fc_mu(latents)\n", " logvar = self.fc_logvar(latents)\n", "\n", " # reparameterize\n", " eps = torch.randn_like(logvar)\n", " std = torch.exp(0.5 * logvar)\n", " z = mu + eps * std\n", "\n", " # decode\n", " x_hat = self.decoder(z).reshape(x.shape)\n", "\n", " # reconstruction loss\n", " recons_loss = F.mse_loss(x_hat, x)\n", " \n", " # KL divergence loss\n", " mu_prior = torch.zeros_like(z)\n", " logvar_prior = torch.zeros_like(z)\n", " kld_loss = kl_loss(mu, logvar, mu_prior, logvar_prior)\n", " kld_loss = torch.sum(kld_loss) / x.shape[0]\n", " \n", " # training loss\n", " loss = recons_loss + self.w_kl * kld_loss \n", " return loss\n", "\n", " def validation_step(self, *args, **kwargs):\n", " # validation logic can be implemented similar to training step\n", " # To make this tutorial simple, we just skip the validation step\n", " return super().validation_step(*args, **kwargs)\n", "\n", " def configure_optimizers(self):\n", " return torch.optim.Adam(self.parameters())" ] }, { "cell_type": "markdown", "id": "c6685699", "metadata": {}, "source": [ "### 2. Dataset Customization\n", "\n", "We provide a `BaseDataModule` for customizing datasets, if the users want to add new datasets. The arguments include:\n", "- seq_len (int): Target sequence length\n", "- seq_dim (int): Target sequence dimension, for univariate time series, set as 1\n", "- condition (str): Possible condition type, choose from [None, 'predict','impute', 'class']. None standards for unconditional generation.\n", "- batch_size (int): Training and validation batch size.\n", " inference_batch_size (int): Testing batch size.\n", "- max_time (float, optional): Time step index [0, 1, ..., `total_seq_len` - 1] will be automatically generated. If `max_time` is given, then scale the time step index, [0, ..., `max_time`]. Defaults to None.\n", "- add_coeffs (str, optional): Include interpolation coefficients or not. Needed for `KoVAE`, `GTGAN` and `SDEGAN`. Choose from `[None, 'linear', 'cubic_spline']`. If `None`, don't include. Defaults to None.\n", "- irregular_dropout (float, optional): Dropout rate to similate irregular time series data by randomly dropout some time steps in the original data. **This is for simulating irregular time series, not for simulating missing values. For simulating missing values for imputation task, please set missing_rate argment** Set between `[0.0, 1.0]` Defaults to 0.0.\n", "- data_dir (str, optional): Directory to save the data file (default name: `\"data_tsl{total_seq_len}_tsd{seq_dim}_ir{irregular_dropout}.pt\"`). Defaults to Path.cwd()/\"data\".\n", "- train_val_test (List[float], optional): Ratios of training, validation and testing dataset. Should be sum as 1.0. Defaults to [0.7, 0.2, 0.1].\n", "- **kwargs: Additional arguments for the dataset\n", "\n", "\n", "----\n", "`BaseDataModule` has already wrapped the logic of train/val/test split, and construction of dataloaders, therefore, users only need to define how the time series data is collected.\n", "\n", "Specifically, users should implement `get_data(self)` method, which should return a triple `(data, data_mask, class_label)`:\n", "- `data`: In shape of `[n_samples, total_seq_len, seq_dim]`, time series data tensor. For each sample, it could be a slided window from the long original time series (for example, a 24-point electricity load curve from a total one-year record), or an individual time series sample (for example, an ECG signal of a patient)\n", "- `data_mask`: In shape of `[n_samples, total_seq_len, seq_dim]` time series data boolean mask tensor, indicating where the original time series have missing values. 0=missing, 1=observed.\n", "- `class_label`: In shape of `[n_samples, ]`, representing the class label of each sample. If there is no class labels, set this to `None`.\n", "\n", "Next, let's go through customizing a simple `SineND` datamodule with total 10k samples." ] }, { "cell_type": "code", "execution_count": 2, "id": "1ee52cdc", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from gents.dataset.base import BaseDataModule\n", "\n", "\n", "class MySineND(BaseDataModule):\n", " def __init__(\n", " self,\n", " seq_len,\n", " seq_dim,\n", " condition,\n", " batch_size=64,\n", " inference_batch_size=512,\n", " max_time=None,\n", " add_coeffs=None,\n", " irregular_dropout=0,\n", " data_dir=\"./data\",\n", " train_val_test=[0.7, 0.2, 0.1],\n", " **kwargs,\n", " ):\n", " super().__init__(\n", " seq_len,\n", " seq_dim,\n", " condition,\n", " batch_size,\n", " inference_batch_size,\n", " max_time,\n", " add_coeffs,\n", " irregular_dropout,\n", " data_dir,\n", " train_val_test,\n", " **kwargs,\n", " )\n", " # 10k size just for illustration\n", " self.num_samples = 10000\n", " self.random_dropout = irregular_dropout\n", " assert irregular_dropout >= 0 and irregular_dropout < 1\n", "\n", " # We only need to customize this function\n", " def get_data(self):\n", " # Initialize the output\n", " data = list()\n", "\n", " # Generate sine data\n", " for i in range(self.num_samples):\n", " # Initialize each time-series\n", " temp = list()\n", " # For each feature\n", " for k in range(self.seq_dim):\n", " # Randomly drawn frequency and phase\n", " freq = np.random.uniform(0.4, 0.6)\n", " phase = np.random.uniform(0, 1.5)\n", "\n", " # Generate sine signal based on the drawn frequency and phase\n", " temp_data = [\n", " np.sin(freq * j + phase) for j in range(self.total_seq_len)\n", " ]\n", " temp.append(temp_data)\n", "\n", " # Align row/column\n", " temp = np.transpose(np.asarray(temp))\n", " # Normalize to [0,1]\n", " temp = (temp + 1) * 0.5\n", " # Stack the generated data\n", " data.append(temp)\n", " data = np.array(data)\n", " data = torch.from_numpy(data).float()\n", "\n", " # data mask\n", " data_mask = torch.ones_like(data)\n", " if self.random_dropout > 0:\n", " mask = torch.bernoulli(\n", " torch.full(\n", " (data.shape[0], data.shape[1]),\n", " 1 - self.random_dropout,\n", " device=data.device,\n", " )\n", " ).unsqueeze(-1)\n", "\n", " data_mask = data_mask * mask\n", " data_mask = data_mask.bool()\n", " # data = data.masked_fill(~data_mask, 0.0)\n", " class_label = None\n", " return data, data_mask.bool(), class_label\n", "\n", " @property\n", " def dataset_name(self) -> str:\n", " return \"SineND\"\n" ] }, { "cell_type": "markdown", "id": "2cfd10b1", "metadata": {}, "source": [ "In `GenTS`, we also standardize the popular time series datasets into `lightning.DataModule`. For a data batch in a dataloader, we have:\n", "- `seq`: `[batch_size, total_seq_len, seq_dim]`. Target time series window\n", "- `t`: `[batch_size, total_seq_len]`. Time step index at each time step in the window. Default [0,1,2,...]\n", "- `data_mask`: `[batch_size, total_seq_len, seq_dim]`. Time series data mask\n", "- `c`: Optional. `[batch_size, obs_len / seq_len]`. Condition. Empty if unconditional.\n", "- `coeffs`: Optional. `[batch_size, total_seq_len, seq_dim]`. Coefficients of cubic spline/linear interp. of NCDE-related models. Empty if no need to interpolate." ] }, { "cell_type": "code", "execution_count": 3, "id": "349efbdf", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'seq': torch.Size([64, 32, 2]), 't': torch.Size([64, 32]), 'data_mask': torch.Size([64, 32, 2])}\n" ] } ], "source": [ "dm_uncond = MySineND(\n", " seq_len=32,\n", " seq_dim=2,\n", " batch_size=64,\n", " # num_samples=3000,\n", " data_dir=\"mydata/\",\n", " condition=None,\n", ")\n", "\n", "# To illustrate a data batch here, we should call prepare_data and setup first\n", "# You can also directly put datamodule into a Trainer, then Trainer will call these two functions automatically\n", "dm_uncond.prepare_data()\n", "dm_uncond.setup('fit')\n", "batch = next(iter(dm_uncond.train_dataloader()))\n", "print({k: v.shape for k, v in batch.items()})" ] }, { "cell_type": "code", "execution_count": 4, "id": "3a2328bc", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "fig, axs = plt.subplots(3)\n", "for i, (k, v) in enumerate(batch.items()):\n", " axs[i].plot(v[0, :])\n", " axs[i].set_title(k)\n", "fig.tight_layout()" ] }, { "cell_type": "markdown", "id": "eaa70a99", "metadata": {}, "source": [ "### 3. setup training\n", "Utilizing `lightning`/`pytorch-lightning`, one can easily set:\n", "- GPU devices\n", "- Training epochs/steps\n", "- Callbacks\n", "- etc.." ] }, { "cell_type": "code", "execution_count": 5, "id": "ffbea7e2", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n", "You are using a CUDA device ('NVIDIA GeForce RTX 3080 Ti') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3]\n", "\n", " | Name | Type | Params | Mode \n", "-------------------------------------------\n", "0 | encoder | MLP | 86.5 K | train\n", "1 | decoder | MLP | 86.6 K | train\n", "2 | fc_mu | MLP | 272 | train\n", "3 | fc_logvar | MLP | 272 | train\n", "-------------------------------------------\n", "173 K Trainable params\n", "0 Non-trainable params\n", "173 K Total params\n", "0.695 Total estimated model params size (MB)\n", "24 Modules in train mode\n", "0 Modules in eval mode\n", "`Trainer.fit` stopped: `max_steps=2000` reached.\n" ] } ], "source": [ "from lightning import Trainer\n", "model = MyVAE(seq_len=32, seq_dim=2, latent_dim=16, condition=None)\n", "# dm_uncond = MySineND(seq_len=32, seq_dim=2, batch_size=64, inference_batch_size=512, condition=None)\n", "trainer = Trainer(max_steps=2000, devices=[0], enable_progress_bar=False)\n", "trainer.fit(model, dm_uncond)" ] }, { "cell_type": "markdown", "id": "8d4b13c8", "metadata": {}, "source": [ "### 4. Sampling from the trained model" ] }, { "cell_type": "code", "execution_count": 6, "id": "6f12b26b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[,\n", " ]" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# generate 10 synthetic samples for illustration\n", "gen_data = model.sample(n_sample=10) # [N, 64, 2]\n", "plt.plot(gen_data[0, :])" ] }, { "cell_type": "markdown", "id": "028c3514", "metadata": {}, "source": [ "## Conditional Case\n", "For conditional generation, we have to (1) set conditions in the dataset, and (2) handle the condition input in the model.\n", "\n", "Here we show case how to perform forecasting with Conditional VAE\n", "\n", "### 1. Conditional Model\n", "Besides the above mentioned arguments, `obs_len` (int, observed length) should also be added as an argument." ] }, { "cell_type": "code", "execution_count": 7, "id": "20c97660", "metadata": {}, "outputs": [], "source": [ "class MyCondVAE(BaseModel):\n", " # Forecasting model\n", " ALLOW_CONDITION = [\"predict\"]\n", "\n", " def __init__(self, seq_len, seq_dim, latent_dim, condition, **kwargs):\n", " super().__init__(seq_len, seq_dim, condition, **kwargs)\n", " self.w_kl = 1e-3 # weight for KL loss\n", " self.seq_len = seq_len\n", " self.seq_dim = seq_dim\n", " self.obs_len = kwargs.get(\"obs_len\")\n", " self.latent_dim = latent_dim\n", "\n", " # Define encoder, decoder and condition embedding networks\n", " self.encoder = MLP(seq_dim * seq_len, [256, 256, latent_dim])\n", " self.decoder = MLP(latent_dim, [256, 256, seq_dim * seq_len])\n", " self.cond_embed = MLP(seq_dim * self.obs_len, [256, 256, latent_dim])\n", "\n", " # z network (concat the condition embedding and sequence embedding)\n", " self.fc_mu = MLP(latent_dim, [latent_dim])\n", " self.fc_logvar = MLP(latent_dim, [latent_dim])\n", "\n", " def _sample_impl(self, n_sample=1, condition=None, **kwargs):\n", " # For conditional model, n_sample is the number of samples per condition\n", " all_samples = []\n", " for i in range(n_sample):\n", " z = torch.randn((condition.shape[0], self.latent_dim)).to(self.device)\n", " cond_lats = self.cond_embed(condition.flatten(1))\n", " z = z + cond_lats\n", " x_hat = self.decoder(z).reshape(\n", " condition.shape[0], self.seq_len, self.seq_dim\n", " )\n", " all_samples.append(x_hat)\n", " all_samples = torch.stack(all_samples, dim=-1)\n", " return all_samples\n", " \n", "\n", " def training_step(self, batch, batch_idx):\n", " # batch['seq'] is the full sequence (obs + pred)\n", " x = batch[\"seq\"][:, -self.seq_len :].flatten(1)\n", " c = batch.get(\"c\")\n", "\n", " # encode \n", " latents = self.encoder(x)\n", " cond_latent = self.cond_embed(c.flatten(1))\n", " latents = latents + cond_latent\n", "\n", " # output the parameters of q(z|x,c)\n", " mu = self.fc_mu(latents)\n", " logvar = self.fc_logvar(latents)\n", "\n", " # reparameterize\n", " eps = torch.randn_like(logvar)\n", " std = torch.exp(0.5 * logvar)\n", " z = mu + eps * std\n", "\n", " # decode\n", " z = z + cond_latent\n", " x_hat = self.decoder(z).reshape(x.shape)\n", "\n", " # reconstruction loss\n", " recons_loss = F.mse_loss(x_hat, x)\n", "\n", " # KL divergence loss\n", " mu_prior = torch.zeros_like(z)\n", " logvar_prior = torch.zeros_like(z)\n", " kld_loss = kl_loss(mu, logvar, mu_prior, logvar_prior)\n", " kld_loss = torch.sum(kld_loss) / x.shape[0]\n", "\n", " # training loss\n", " loss = recons_loss + self.w_kl * kld_loss\n", " return loss\n", "\n", " def validation_step(self, *args, **kwargs):\n", " # validation logic can be implemented similar to training step\n", " # To make this tutorial simple, we just skip the validation step\n", " return super().validation_step(*args, **kwargs)\n", "\n", " def configure_optimizers(self):\n", " return torch.optim.Adam(self.parameters())" ] }, { "cell_type": "markdown", "id": "2b830909", "metadata": {}, "source": [ "Visualize the forecasting data batch" ] }, { "cell_type": "code", "execution_count": 8, "id": "cb099243", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'seq': torch.Size([64, 64, 2]), 't': torch.Size([64, 64]), 'data_mask': torch.Size([64, 64, 2]), 'c': torch.Size([64, 32, 2])}\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "dm_cond = MySineND(\n", " seq_len=32,\n", " seq_dim=2,\n", " obs_len=32,\n", " batch_size=64,\n", " # num_samples=3000,\n", " data_dir=\"mydata_cond/\",\n", " condition='predict',\n", ")\n", "\n", "# To illustrate a data batch here, we should call prepare_data and setup first\n", "# You can also directly put datamodule into a Trainer, then Trainer will call these two functions automatically\n", "dm_cond.prepare_data()\n", "dm_cond.setup('fit')\n", "batch = next(iter(dm_cond.train_dataloader()))\n", "print({k: v.shape for k, v in batch.items()})\n", "\n", "fig, axs = plt.subplots(3)\n", "for i, (k, v) in enumerate(batch.items()):\n", " if k == 'c':\n", " axs[0].plot(v[0, :], label=['obs_chnl1', 'obs_chnl2'], lw=3)\n", " axs[0].legend()\n", " else:\n", " axs[i].plot(v[0, :])\n", " axs[i].set_title(k)\n", "fig.tight_layout()" ] }, { "cell_type": "code", "execution_count": 9, "id": "2df757e6", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2,3]\n", "\n", " | Name | Type | Params | Mode \n", "--------------------------------------------\n", "0 | encoder | MLP | 86.5 K | train\n", "1 | decoder | MLP | 86.6 K | train\n", "2 | cond_embed | MLP | 86.5 K | train\n", "3 | fc_mu | MLP | 272 | train\n", "4 | fc_logvar | MLP | 272 | train\n", "--------------------------------------------\n", "260 K Trainable params\n", "0 Non-trainable params\n", "260 K Total params\n", "1.041 Total estimated model params size (MB)\n", "33 Modules in train mode\n", "0 Modules in eval mode\n", "`Trainer.fit` stopped: `max_steps=2500` reached.\n" ] } ], "source": [ "model = MyCondVAE(seq_len=32, obs_len=32, seq_dim=2, latent_dim=16, condition='predict')\n", "trainer = Trainer(max_steps=2500, devices=[0], enable_progress_bar=False)\n", "trainer.fit(model, dm_cond)" ] }, { "cell_type": "code", "execution_count": 10, "id": "2b3ed664", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from gents.evaluation import predict_visual\n", "\n", "dm_cond.setup(\"test\")\n", "real_data = torch.cat([batch[\"seq\"] for batch in dm_cond.test_dataloader()])\n", "cond_data = torch.cat([batch[\"c\"] for batch in dm_cond.test_dataloader()])\n", "\n", "gen_data = model.sample(\n", " n_sample=10,\n", " condition=cond_data,\n", ")\n", "\n", "predict_visual(\n", " real_data=real_data,\n", " gen_data=gen_data,\n", " data_mask=torch.ones_like(real_data).bool(),\n", " # uncomment the following line to save the plot\n", " # save_root='./predict.png'\n", ")" ] } ], "metadata": { "kernelspec": { "display_name": "gents", "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.10.19" } }, "nbformat": 4, "nbformat_minor": 5 }