{ "cells": [ { "cell_type": "markdown", "id": "33f39229508719ea", "metadata": { "collapsed": false }, "source": [ "# Active Image Classification via Self-supervised Learning" ] }, { "cell_type": "markdown", "id": "fd4eb6e7", "metadata": {}, "source": [ "> **_Google Colab Note:_** If the notebook fails to run after installing the needed packages, try to restart the runtime (Ctrl + M) under Runtime -> Restart session.\n", "\n", "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/scikit-activeml/scikit-activeml.github.io/blob/gh-pages/latest/generated/tutorials_colab//05_pool_al_with_self_supervised_learning.ipynb)" ] }, { "cell_type": "markdown", "id": "79402ebb", "metadata": {}, "source": [ "**Notebook Dependencies**\n", "\n", "Uncomment the following cells to install all dependencies for this tutorial." ] }, { "cell_type": "code", "execution_count": 1, "id": "0c5bb17e", "metadata": {}, "outputs": [], "source": [ "# !pip install scikit-activeml torch torchvision torchaudio tqdm" ] }, { "cell_type": "markdown", "id": "a773fbde", "metadata": {}, "source": [ "
" ] }, { "cell_type": "markdown", "id": "fa4583e83ede8da9", "metadata": { "collapsed": false }, "source": [ "This tutorial aims to demonstrate a practical comparison study using our ```scikit-activeml``` library. The workflow involves utilizing a self-supervised learning model, specifically ```DINOv2``` from [1], to generate embeddings for the Flowers-102 dataset [2]. Subsequently, various active learning strategies will be employed to intelligently select samples for labeling.\n", "\n", "**Key Steps:**\n", "1. **Self-Supervised Learning Model:** Utilize the DINOv2 model to create embedding dataset for Flowers-102 dataset.\n", "\n", "2. **Active Learning Strategies:** Employ different active learning strategies provided by our library, including:\n", " - Random Sampling\n", " - Uncertainty Sampling\n", " - Discriminative Active Learning (DiscriminativeAL)\n", " - CoreSet\n", " - TypiClust\n", " - Badge\n", " - ProbCover\n", " - DropQuery\n", " - Falcun\n", "\n", "3. **Batch Sample Selection:** Use each active learning strategy to select a batch of samples for labeling.\n", "\n", "4. **Plotting the results:** By the end of this notebook, we'll compare the accuracy of the aforementioned active learning strategies.\n", "\n", "**References:**\n", "\n", "[1] M. Oquab et al., 'DINOv2: Learning Robust Visual Features without Supervision'. Transactions on Machine Learning Research (TMLR)\n", "\n", "[2] M. E. Nilsback and A. Zisserman, 'Automated Flower Classification over a Large Number of Classes'. Indian Conference on Computer Vision, Graphics and Image Processing (ICVGIP)" ] }, { "cell_type": "code", "execution_count": 2, "id": "3a4b6dbb9143a5eb", "metadata": { "ExecuteTime": { "end_time": "2024-02-16T17:58:49.361696Z", "start_time": "2024-02-16T17:58:47.694499Z" }, "collapsed": false }, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib as mlp\n", "import matplotlib.pyplot as plt\n", "\n", "from sklearn.linear_model import LogisticRegression\n", "\n", "from skactiveml.classifier import SklearnClassifier\n", "from skactiveml.pool import (\n", " UncertaintySampling,\n", " RandomSampling,\n", " DiscriminativeAL,\n", " CoreSet,\n", " TypiClust,\n", " Badge,\n", " DropQuery,\n", " ProbCover,\n", " Falcun\n", ")\n", "from skactiveml.utils import call_func, MISSING_LABEL\n", "\n", "import torch\n", "import torchvision.datasets as datasets\n", "import torchvision.transforms as transforms\n", "from tqdm import tqdm\n", "\n", "import warnings\n", "mlp.rcParams[\"figure.facecolor\"] = \"white\"\n", "warnings.filterwarnings(\"ignore\")" ] }, { "cell_type": "markdown", "id": "3ac32ea901e08c01", "metadata": { "collapsed": false }, "source": [ "## Prepare Data with DINOv2" ] }, { "cell_type": "markdown", "id": "7a4e3bf805669b1c", "metadata": { "collapsed": false }, "source": [ "In this step, we focus on preparing the datasets using the self-supervised learning model DINOv2. DINOv2, short for \"self-distillation with no labels\", is a state-of-the-art model that excels at learning meaningful representations from unlabeled data.\n", "\n", "If you've already completed these steps, you can skip ahead to loading your data. " ] }, { "cell_type": "markdown", "id": "9c0819f4-b45f-4285-aa1d-84469764b6a5", "metadata": {}, "source": [ "**Step 1: Transformation**\n", "\n", "Apply necessary transformations to the datasets, including resizing images to a standardized format. This ensures consistency of input dimensions with the DINOv2 model." ] }, { "cell_type": "code", "execution_count": 3, "id": "3b27a5c395f5897e", "metadata": { "ExecuteTime": { "end_time": "2024-02-16T17:58:55.815281Z", "start_time": "2024-02-16T17:58:55.810506Z" }, "collapsed": false }, "outputs": [], "source": [ "transforms = transforms.Compose(\n", " [transforms.Resize(256),\n", " transforms.CenterCrop(224),\n", " transforms.ToTensor(),\n", " transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))]\n", " )" ] }, { "cell_type": "markdown", "id": "0493d78a-c3d5-42b3-b5b6-b83191d4bbe1", "metadata": {}, "source": [ "**Step 2: Load pretrained Model**\n", "To calculate embeddings, we'll use DINOv2. Below we load the second smallest DINOv2 model to generate embedding datasets for the Flowers-102 datasets. " ] }, { "cell_type": "code", "execution_count": 4, "id": "387db871-7e26-46d0-9722-45c71ed40014", "metadata": { "ExecuteTime": { "end_time": "2024-02-16T18:04:27.290216Z", "start_time": "2024-02-16T18:03:24.949961Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Using cache found in cache/facebookresearch_dinov2_main\n" ] }, { "data": { "text/plain": [ "DinoVisionTransformer(\n", " (patch_embed): PatchEmbed(\n", " (proj): Conv2d(3, 768, kernel_size=(14, 14), stride=(14, 14))\n", " (norm): Identity()\n", " )\n", " (blocks): ModuleList(\n", " (0-11): 12 x NestedTensorBlock(\n", " (norm1): LayerNorm((768,), eps=1e-06, elementwise_affine=True)\n", " (attn): MemEffAttention(\n", " (qkv): Linear(in_features=768, out_features=2304, bias=True)\n", " (attn_drop): Dropout(p=0.0, inplace=False)\n", " (proj): Linear(in_features=768, out_features=768, bias=True)\n", " (proj_drop): Dropout(p=0.0, inplace=False)\n", " )\n", " (ls1): LayerScale()\n", " (drop_path1): Identity()\n", " (norm2): LayerNorm((768,), eps=1e-06, elementwise_affine=True)\n", " (mlp): Mlp(\n", " (fc1): Linear(in_features=768, out_features=3072, bias=True)\n", " (act): GELU(approximate='none')\n", " (fc2): Linear(in_features=3072, out_features=768, bias=True)\n", " (drop): Dropout(p=0.0, inplace=False)\n", " )\n", " (ls2): LayerScale()\n", " (drop_path2): Identity()\n", " )\n", " )\n", " (norm): LayerNorm((768,), eps=1e-06, elementwise_affine=True)\n", " (head): Identity()\n", ")" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "torch.hub.set_dir('cache/')\n", "\n", "dinov2_vitb14 = torch.hub.load(\"facebookresearch/dinov2\", \"dinov2_vitb14\")\n", "\n", "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", "\n", "dinov2_vitb14.to(device)" ] }, { "cell_type": "markdown", "id": "7668a073b61085ea", "metadata": { "collapsed": false }, "source": [ "**Step 3: Load Datasets and Generate Embeddings**\n", "\n", "Firstly, we begin by loading the Flowers-102 dataset.\n", "\n", "After that, we employ the pre-trained DINOv2 model to generate embeddings for each image in the dataset and save them in a npy file." ] }, { "cell_type": "code", "execution_count": 5, "id": "8c0165be-d3ce-4eb2-9309-45ba6c08c8d3", "metadata": { "ExecuteTime": { "end_time": "2024-02-16T18:08:01.968032Z", "start_time": "2024-02-16T18:08:01.959921Z" } }, "outputs": [], "source": [ "def load_and_process_dataset(root_dir, is_train, batch_size=4):\n", " \"\"\"\n", " Load and process a given dataset for training or validation.\n", "\n", " Parameters:\n", " - root_dir (str) : Root directory where the dataset will be stored.\n", " - is_train (bool) : Boolean indicating whether the dataset is for training (True) or validation (False).\n", " - batch_size (int) : The batch_size used for the DataLoader.\n", "\n", " Returns:\n", " - X (numpy.ndarray): Concatenated embeddings of the dataset.\n", " - y_true (numpy.ndarray): Concatenated true labels of the dataset.\n", " \"\"\"\n", "\n", " # Load dataset\n", " if is_train:\n", " split = 'train'\n", " else:\n", " split = 'val'\n", "\n", " dataset = datasets.Flowers102(root=root_dir, split=split, download=True, transform=transforms)\n", "\n", "\n", " # Create DataLoader\n", " dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=is_train, num_workers=2)\n", "\n", " embedding_list = []\n", " label_list = []\n", "\n", " # Iterate through the DataLoader and extract embeddings\n", " with torch.no_grad():\n", " for i, data in tqdm(enumerate(dataloader), total=len(dataloader), desc=f\"Flowers102 {split}\"):\n", " image, label = data\n", " embeddings = dinov2_vitb14(image.to(device)).cpu()\n", " embedding_list.append(embeddings)\n", " label_list.append(label)\n", "\n", " # Concatenate embeddings and labels\n", " X = torch.cat(embedding_list, dim=0).numpy()\n", " y_true = torch.cat(label_list, dim=0).numpy()\n", "\n", " return X, y_true" ] }, { "cell_type": "markdown", "id": "b0ac7d46-ab15-4aaf-ad72-2f600c227cd9", "metadata": {}, "source": [ "Applying on Flowers102 Datasets" ] }, { "cell_type": "code", "execution_count": 6, "id": "b9c0fa197cbde9a", "metadata": { "ExecuteTime": { "end_time": "2024-02-16T18:08:03.651976Z", "start_time": "2024-02-16T18:08:03.649154Z" }, "collapsed": false }, "outputs": [], "source": [ "data_dir = \"./data\"" ] }, { "cell_type": "code", "execution_count": 7, "id": "4abc295a-f41d-42aa-9b02-3a9fffc28b1d", "metadata": { "ExecuteTime": { "end_time": "2024-02-16T18:15:55.521694Z", "start_time": "2024-02-16T18:12:23.843887Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Flowers102 train: 100%|██████████| 255/255 [00:08<00:00, 30.83it/s]\n", "Flowers102 val: 100%|██████████| 255/255 [00:08<00:00, 31.43it/s]\n" ] } ], "source": [ "# Flowers-102\n", "flowers102_X_train, flowers102_y_train_true = load_and_process_dataset(data_dir, True)\n", "flowers102_X_test, flowers102_y_test_true = load_and_process_dataset(data_dir, False)\n", "\n", "np.save(f'{data_dir}/flowers102_dinov2B_X_train.npy', flowers102_X_train)\n", "np.save(f'{data_dir}/flowers102_dinov2B_y_train.npy', flowers102_y_train_true)\n", "np.save(f'{data_dir}/flowers102_dinov2B_X_test.npy', flowers102_X_test)\n", "np.save(f'{data_dir}/flowers102_dinov2B_y_test.npy', flowers102_y_test_true)" ] }, { "cell_type": "markdown", "id": "fe0757f8-9261-4510-90cd-8a2a8707add7", "metadata": {}, "source": [ "## Load your preprocessed Dataset\n", "\n", "If you have previously processed your data with DINOv2, please use the following code to load your data. And we also define the number of classes in the Flowers102 dataset." ] }, { "cell_type": "code", "execution_count": 8, "id": "8fd85d019561dd8d", "metadata": { "ExecuteTime": { "end_time": "2024-02-16T18:16:00.131931Z", "start_time": "2024-02-16T18:16:00.127759Z" }, "collapsed": false }, "outputs": [], "source": [ "data_dir = \"./data\"" ] }, { "cell_type": "code", "execution_count": 9, "id": "e29fc457-2fb1-4824-8cd5-b637e44795a8", "metadata": { "ExecuteTime": { "end_time": "2024-02-16T18:16:09.760397Z", "start_time": "2024-02-16T18:16:09.744836Z" } }, "outputs": [], "source": [ "# Flowers-102\n", "X_train = np.load(f'{data_dir}/flowers102_dinov2B_X_train.npy')\n", "y_train_true = np.load(f'{data_dir}/flowers102_dinov2B_y_train.npy')\n", "X_test = np.load(f'{data_dir}/flowers102_dinov2B_X_test.npy')\n", "y_test_true = np.load(f'{data_dir}/flowers102_dinov2B_y_test.npy')\n", "\n", "dataset_classes = 102" ] }, { "cell_type": "markdown", "id": "cf4565232ae31432", "metadata": { "collapsed": false }, "source": [ "## Random Seed Management" ] }, { "cell_type": "markdown", "id": "b1ce38a2-0305-44eb-abf5-cb69c41c3f98", "metadata": {}, "source": [ "To ensure experiment reproducibility, it's important to set random states for all components that might use them. For simplicity, we set a single fixed random state and use helper functions to generate new seeds and random states. It's important to note that the ```master_random_state``` should only be used to create new random states or random seeds." ] }, { "cell_type": "code", "execution_count": 10, "id": "11e6ce648a9ab110", "metadata": { "ExecuteTime": { "end_time": "2024-02-16T18:16:16.503717Z", "start_time": "2024-02-16T18:16:16.497010Z" }, "collapsed": false }, "outputs": [], "source": [ "master_random_state = np.random.RandomState(0)\n", "\n", "def gen_seed(random_state:np.random.RandomState):\n", " \"\"\"\n", " Generate a seed for a random number generator.\n", "\n", " Parameters:\n", " - random_state (np.random.RandomState): Random state object.\n", "\n", " Returns:\n", " - int: Generated seed.\n", " \"\"\"\n", " return random_state.randint(0, 2**31)\n", "\n", "def gen_random_state(random_state:np.random.RandomState):\n", " \"\"\"\n", " Generate a new random state object based on a given random state.\n", "\n", " Parameters:\n", " - random_state (np.random.RandomState): Random state object.\n", "\n", " Returns:\n", " - np.random.RandomState: New random state object.\n", " \"\"\"\n", " return np.random.RandomState(gen_seed(random_state))" ] }, { "cell_type": "markdown", "id": "24cc0c5019b852b5", "metadata": { "collapsed": false }, "source": [ "## Classification Models and Query Strategies" ] }, { "cell_type": "markdown", "id": "91a3743e-cb9e-49a9-a239-30c9f54839fa", "metadata": {}, "source": [ "The embeddings we have computed can be used as an input to a classification model. For this guide, we use `LogisticRegression` from `sklearn`. Moreover, we handle the creation of query strategies using factory functions to simplify the separation of query strategies across repetitions." ] }, { "cell_type": "code", "execution_count": 11, "id": "d356c3752b0a58a1", "metadata": { "ExecuteTime": { "end_time": "2024-02-16T18:16:19.280308Z", "start_time": "2024-02-16T18:16:19.273518Z" }, "collapsed": false }, "outputs": [], "source": [ "clf = SklearnClassifier(LogisticRegression(), classes=np.arange(dataset_classes), random_state=gen_seed(master_random_state))\n", "\n", "def create_query_strategy(name, random_state):\n", " return query_strategy_factory_functions[name](random_state)\n", "\n", "query_strategy_factory_functions = {\n", " 'RandomSampling': lambda random_state: RandomSampling(random_state=gen_seed(random_state)),\n", " 'UncertaintySampling': lambda random_state: UncertaintySampling(random_state=gen_seed(random_state)),\n", " 'DiscriminativeAL': lambda random_state: DiscriminativeAL(random_state=gen_seed(random_state)),\n", " 'CoreSet': lambda random_state: CoreSet(random_state=gen_seed(random_state)),\n", " 'TypiClust': lambda random_state: TypiClust(random_state=gen_seed(random_state)),\n", " 'Badge': lambda random_state: Badge(random_state=gen_seed(random_state)),\n", " 'DropQuery': lambda random_state: DropQuery(random_state=gen_seed(random_state)),\n", " 'ProbCover': lambda random_state: ProbCover(random_state=gen_seed(random_state)),\n", " 'Falcun': lambda random_state: Falcun(random_state=gen_seed(random_state))\n", "}" ] }, { "cell_type": "markdown", "id": "9023c37048ec8f54", "metadata": { "collapsed": false }, "source": [ "## Experiment Parameters\n", "\n", "For this experiment, we need to define how the strategies should be compared against one another. Here the number of repetitions (```n_reps```), the number of cycles (```n_cycles```), and the size of each query (```query_batch_size```) need to be defined. " ] }, { "cell_type": "code", "execution_count": 12, "id": "e103670190e73a3f", "metadata": { "ExecuteTime": { "end_time": "2024-02-16T18:16:22.477680Z", "start_time": "2024-02-16T18:16:22.469634Z" }, "collapsed": false }, "outputs": [], "source": [ "n_reps = 3\n", "n_cycles = 30\n", "query_batch_size = 8\n", "query_strategy_names = query_strategy_factory_functions.keys()" ] }, { "cell_type": "markdown", "id": "66b8fff1b12211ed", "metadata": { "collapsed": false }, "source": [ "## Experiment Loop\n", "\n", "The actual experiment loops over all query strategies. The accuracy for the test set is stored for each cycle and repetition in the `results` dictionary." ] }, { "cell_type": "code", "execution_count": 13, "id": "718629bb-1c4f-4707-9eb1-9d1df901cd84", "metadata": { "ExecuteTime": { "end_time": "2024-02-16T18:33:37.013276Z", "start_time": "2024-02-16T18:16:23.899324Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Repeat 1 with RandomSampling: 100%|██████████| 30/30 [00:01<00:00, 28.19it/s]\n", "Repeat 2 with RandomSampling: 100%|██████████| 30/30 [00:01<00:00, 25.93it/s]\n", "Repeat 3 with RandomSampling: 100%|██████████| 30/30 [00:01<00:00, 29.28it/s]\n", "Repeat 1 with UncertaintySampling: 100%|██████████| 30/30 [00:02<00:00, 12.27it/s]\n", "Repeat 2 with UncertaintySampling: 100%|██████████| 30/30 [00:02<00:00, 12.83it/s]\n", "Repeat 3 with UncertaintySampling: 100%|██████████| 30/30 [00:02<00:00, 12.04it/s]\n", "Repeat 1 with DiscriminativeAL: 100%|██████████| 30/30 [00:11<00:00, 2.63it/s]\n", "Repeat 2 with DiscriminativeAL: 100%|██████████| 30/30 [00:11<00:00, 2.64it/s]\n", "Repeat 3 with DiscriminativeAL: 100%|██████████| 30/30 [00:11<00:00, 2.67it/s]\n", "Repeat 1 with CoreSet: 100%|██████████| 30/30 [00:07<00:00, 4.14it/s]\n", "Repeat 2 with CoreSet: 100%|██████████| 30/30 [00:07<00:00, 4.24it/s]\n", "Repeat 3 with CoreSet: 100%|██████████| 30/30 [00:07<00:00, 4.26it/s]\n", "Repeat 1 with TypiClust: 100%|██████████| 30/30 [00:13<00:00, 2.25it/s]\n", "Repeat 2 with TypiClust: 100%|██████████| 30/30 [00:13<00:00, 2.21it/s]\n", "Repeat 3 with TypiClust: 100%|██████████| 30/30 [00:13<00:00, 2.23it/s]\n", "Repeat 1 with Badge: 100%|██████████| 30/30 [00:24<00:00, 1.21it/s]\n", "Repeat 2 with Badge: 100%|██████████| 30/30 [00:24<00:00, 1.22it/s]\n", "Repeat 3 with Badge: 100%|██████████| 30/30 [00:24<00:00, 1.22it/s]\n", "Repeat 1 with DropQuery: 100%|██████████| 30/30 [00:05<00:00, 5.82it/s]\n", "Repeat 2 with DropQuery: 100%|██████████| 30/30 [00:05<00:00, 5.99it/s]\n", "Repeat 3 with DropQuery: 100%|██████████| 30/30 [00:04<00:00, 6.21it/s]\n", "Repeat 1 with ProbCover: 100%|██████████| 30/30 [00:01<00:00, 26.13it/s]\n", "Repeat 2 with ProbCover: 100%|██████████| 30/30 [00:01<00:00, 20.10it/s]\n", "Repeat 3 with ProbCover: 100%|██████████| 30/30 [00:01<00:00, 24.46it/s]\n", "Repeat 1 with Falcun: 100%|██████████| 30/30 [00:02<00:00, 10.09it/s]\n", "Repeat 2 with Falcun: 100%|██████████| 30/30 [00:02<00:00, 10.73it/s]\n", "Repeat 3 with Falcun: 100%|██████████| 30/30 [00:03<00:00, 9.57it/s]\n" ] } ], "source": [ "results = {}\n", "\n", "for qs_name in query_strategy_names:\n", " accuracies = np.full((n_reps, n_cycles), np.nan)\n", " for i_rep in range(n_reps):\n", " y_train = np.full(shape=y_train_true.shape, fill_value=MISSING_LABEL)\n", "\n", " qs = create_query_strategy(qs_name, random_state=gen_random_state(np.random.RandomState(i_rep)))\n", " clf.fit(X_train, y_train)\n", "\n", " for c in tqdm(range(n_cycles), desc=f'Repeat {i_rep + 1} with {qs_name}'):\n", " query_idx = call_func(qs.query, X=X_train, y=y_train, batch_size=query_batch_size, clf=clf, discriminator=clf)\n", " y_train[query_idx] = y_train_true[query_idx]\n", " clf.fit(X_train, y_train)\n", " score = clf.score(X_test, y_test_true)\n", " accuracies[i_rep, c] = score\n", "\n", " results[qs_name] = accuracies" ] }, { "cell_type": "markdown", "id": "998e52cb1a2107b", "metadata": { "collapsed": false }, "source": [ "## Resulting Plotting\n", "\n", "We use learning curves to compare strategies. We visualize the average accuracy over all repetitions. In addition, the legend provides insight into the area under the learning curve, which indicates the average accuracy over all cycles." ] }, { "cell_type": "code", "execution_count": 14, "id": "7ed6ebe52431f489", "metadata": { "ExecuteTime": { "end_time": "2024-02-16T18:33:44.893333Z", "start_time": "2024-02-16T18:33:44.750552Z" }, "collapsed": false }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "for qs_name in query_strategy_names:\n", " key = qs_name\n", " result = results[key]\n", " reshaped_result = result.reshape((-1, n_cycles))\n", " errorbar_mean = np.mean(reshaped_result, axis=0)\n", " errorbar_std = np.std(reshaped_result, axis=0)\n", " plt.errorbar(np.arange(1, n_cycles+1), errorbar_mean, errorbar_std, label=f\"({np.mean(errorbar_mean):.4f}) {qs_name}\", alpha=0.5)\n", "plt.title(f\"LogisticRegression with query batch size {query_batch_size}\")\n", "plt.legend(loc='lower right')\n", "plt.xlabel('cycle')\n", "plt.ylabel('accuracy')\n", "plt.show()" ] } ], "metadata": { "kernelspec": { "display_name": "skaml_skorch", "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.11.11" } }, "nbformat": 4, "nbformat_minor": 5 }