{ "cells": [ { "cell_type": "code", "execution_count": 1, "id": "d128a462-562e-48ea-9245-5f7f4b516a51", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Requirement already satisfied: transformers in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (4.47.0)\n", "Requirement already satisfied: torch in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (2.5.1)\n", "Requirement already satisfied: torchvision in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (0.20.1)\n", "Requirement already satisfied: filelock in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from transformers) (3.16.1)\n", "Requirement already satisfied: huggingface-hub<1.0,>=0.24.0 in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from transformers) (0.27.0)\n", "Requirement already satisfied: numpy>=1.17 in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from transformers) (2.1.0)\n", "Requirement already satisfied: packaging>=20.0 in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from transformers) (24.1)\n", "Requirement already satisfied: pyyaml>=5.1 in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from transformers) (6.0.2)\n", "Requirement already satisfied: regex!=2019.12.17 in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from transformers) (2024.11.6)\n", "Requirement already satisfied: requests in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from transformers) (2.32.3)\n", "Requirement already satisfied: tokenizers<0.22,>=0.21 in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from transformers) (0.21.0)\n", "Requirement already satisfied: safetensors>=0.4.1 in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from transformers) (0.4.5)\n", "Requirement already satisfied: tqdm>=4.27 in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from transformers) (4.66.5)\n", "Requirement already satisfied: typing-extensions>=4.8.0 in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from torch) (4.12.2)\n", "Requirement already satisfied: networkx in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from torch) (3.4.2)\n", "Requirement already satisfied: jinja2 in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from torch) (3.1.4)\n", "Requirement already satisfied: fsspec in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from torch) (2024.9.0)\n", "Requirement already satisfied: setuptools in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from torch) (72.2.0)\n", "Requirement already satisfied: sympy==1.13.1 in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from torch) (1.13.1)\n", "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from sympy==1.13.1->torch) (1.3.0)\n", "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from torchvision) (10.4.0)\n", "Requirement already satisfied: MarkupSafe>=2.0 in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from jinja2->torch) (2.1.5)\n", "Requirement already satisfied: charset-normalizer<4,>=2 in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from requests->transformers) (3.3.2)\n", "Requirement already satisfied: idna<4,>=2.5 in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from requests->transformers) (3.8)\n", "Requirement already satisfied: urllib3<3,>=1.21.1 in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from requests->transformers) (2.2.2)\n", "Requirement already satisfied: certifi>=2017.4.17 in /Users/shoni/Library/jupyterlab-desktop/jlab_server/lib/python3.12/site-packages (from requests->transformers) (2024.7.4)\n" ] } ], "source": [ "# **Fine-Tune gaborcselle/font-identifier for Comic Sans vs Not Comic Sans**\n", "!pip install transformers torch torchvision" ] }, { "cell_type": "code", "execution_count": 2, "id": "384d1068-1f49-477f-9600-25587abb7a40", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "ResNetForImageClassification(\n", " (resnet): ResNetModel(\n", " (embedder): ResNetEmbeddings(\n", " (embedder): ResNetConvLayer(\n", " (convolution): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n", " (normalization): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (activation): ReLU()\n", " )\n", " (pooler): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", " )\n", " (encoder): ResNetEncoder(\n", " (stages): ModuleList(\n", " (0): ResNetStage(\n", " (layers): Sequential(\n", " (0): ResNetBasicLayer(\n", " (shortcut): Identity()\n", " (layer): Sequential(\n", " (0): ResNetConvLayer(\n", " (convolution): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", " (normalization): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (activation): ReLU()\n", " )\n", " (1): ResNetConvLayer(\n", " (convolution): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", " (normalization): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (activation): Identity()\n", " )\n", " )\n", " (activation): ReLU()\n", " )\n", " (1): ResNetBasicLayer(\n", " (shortcut): Identity()\n", " (layer): Sequential(\n", " (0): ResNetConvLayer(\n", " (convolution): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", " (normalization): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (activation): ReLU()\n", " )\n", " (1): ResNetConvLayer(\n", " (convolution): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", " (normalization): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (activation): Identity()\n", " )\n", " )\n", " (activation): ReLU()\n", " )\n", " )\n", " )\n", " (1): ResNetStage(\n", " (layers): Sequential(\n", " (0): ResNetBasicLayer(\n", " (shortcut): ResNetShortCut(\n", " (convolution): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", " (normalization): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " )\n", " (layer): Sequential(\n", " (0): ResNetConvLayer(\n", " (convolution): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", " (normalization): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (activation): ReLU()\n", " )\n", " (1): ResNetConvLayer(\n", " (convolution): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", " (normalization): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (activation): Identity()\n", " )\n", " )\n", " (activation): ReLU()\n", " )\n", " (1): ResNetBasicLayer(\n", " (shortcut): Identity()\n", " (layer): Sequential(\n", " (0): ResNetConvLayer(\n", " (convolution): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", " (normalization): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (activation): ReLU()\n", " )\n", " (1): ResNetConvLayer(\n", " (convolution): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", " (normalization): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (activation): Identity()\n", " )\n", " )\n", " (activation): ReLU()\n", " )\n", " )\n", " )\n", " (2): ResNetStage(\n", " (layers): Sequential(\n", " (0): ResNetBasicLayer(\n", " (shortcut): ResNetShortCut(\n", " (convolution): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", " (normalization): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " )\n", " (layer): Sequential(\n", " (0): ResNetConvLayer(\n", " (convolution): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", " (normalization): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (activation): ReLU()\n", " )\n", " (1): ResNetConvLayer(\n", " (convolution): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", " (normalization): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (activation): Identity()\n", " )\n", " )\n", " (activation): ReLU()\n", " )\n", " (1): ResNetBasicLayer(\n", " (shortcut): Identity()\n", " (layer): Sequential(\n", " (0): ResNetConvLayer(\n", " (convolution): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", " (normalization): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (activation): ReLU()\n", " )\n", " (1): ResNetConvLayer(\n", " (convolution): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", " (normalization): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (activation): Identity()\n", " )\n", " )\n", " (activation): ReLU()\n", " )\n", " )\n", " )\n", " (3): ResNetStage(\n", " (layers): Sequential(\n", " (0): ResNetBasicLayer(\n", " (shortcut): ResNetShortCut(\n", " (convolution): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", " (normalization): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " )\n", " (layer): Sequential(\n", " (0): ResNetConvLayer(\n", " (convolution): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", " (normalization): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (activation): ReLU()\n", " )\n", " (1): ResNetConvLayer(\n", " (convolution): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", " (normalization): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (activation): Identity()\n", " )\n", " )\n", " (activation): ReLU()\n", " )\n", " (1): ResNetBasicLayer(\n", " (shortcut): Identity()\n", " (layer): Sequential(\n", " (0): ResNetConvLayer(\n", " (convolution): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", " (normalization): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (activation): ReLU()\n", " )\n", " (1): ResNetConvLayer(\n", " (convolution): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", " (normalization): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (activation): Identity()\n", " )\n", " )\n", " (activation): ReLU()\n", " )\n", " )\n", " )\n", " )\n", " )\n", " (pooler): AdaptiveAvgPool2d(output_size=(1, 1))\n", " )\n", " (classifier): Sequential(\n", " (0): Flatten(start_dim=1, end_dim=-1)\n", " (1): Dropout(p=0.3, inplace=False)\n", " (2): Linear(in_features=512, out_features=2, bias=True)\n", " )\n", ")" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 1. Load the pre-trained model and processor\n", "import random\n", "import torch\n", "import numpy as np\n", "from transformers import AutoImageProcessor, AutoModelForImageClassification\n", "import torch.nn as nn\n", "\n", "# Set random seeds for reproducibility\n", "seed = 42\n", "random.seed(seed)\n", "np.random.seed(seed)\n", "torch.manual_seed(seed)\n", "torch.cuda.manual_seed_all(seed)\n", "\n", "torch.backends.cudnn.deterministic = True\n", "torch.backends.cudnn.benchmark = False\n", "\n", "# Load the model and processor\n", "processor = AutoImageProcessor.from_pretrained(\"gaborcselle/font-identifier\")\n", "model = AutoModelForImageClassification.from_pretrained(\"gaborcselle/font-identifier\")\n", "\n", "# Modify the final classification layer for binary output and add Dropout\n", "model.classifier = nn.Sequential(\n", " nn.Flatten(),\n", " nn.Dropout(0.3), # Add Dropout for regularization\n", " nn.Linear(model.classifier[1].in_features, 2) # 2-class output\n", ")\n", "\n", "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "model.to(device)\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "1638ebe2-9c98-44eb-aeba-426b7032205c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Class-to-Index Mapping: {'comic': 0, 'not-comic': 1}\n" ] } ], "source": [ "# Section 2: Dataset Preparation with Correct Label Mapping\n", "from torchvision import datasets, transforms\n", "from torch.utils.data import DataLoader, random_split\n", "\n", "# Dataset path\n", "# /data/comic and /data/not-comic\n", "data_dir = \"./data\"\n", "\n", "# Apply augmentations and normalization\n", "transform = transforms.Compose([\n", " transforms.Resize((224, 224)),\n", " transforms.RandomRotation(15),\n", " transforms.RandomHorizontalFlip(),\n", " transforms.ToTensor(),\n", " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", "])\n", "\n", "# Load dataset with target_transform to fix flipped labels\n", "full_dataset = datasets.ImageFolder(\n", " data_dir, \n", " transform=transform,\n", " target_transform=lambda x: 1 - x # Flip the labels: 0 -> 1, 1 -> 0\n", ")\n", "\n", "# Verify class-to-index mapping\n", "print(f\"Class-to-Index Mapping: {full_dataset.class_to_idx}\")\n", "\n", "# Train/Validation Split\n", "train_size = int(0.8 * len(full_dataset)) # 80% train, 20% validation\n", "val_size = len(full_dataset) - train_size\n", "\n", "train_dataset, val_dataset = random_split(full_dataset, [train_size, val_size])\n", "\n", "# Dataloaders for training and validation\n", "train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)\n", "val_loader = DataLoader(val_dataset, batch_size=16, shuffle=False)\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "f8171242-0633-47d1-b365-b594a72e5259", "metadata": {}, "outputs": [], "source": [ "# 3. Fine-Tuning: Optimizer with weight decay and learning rate scheduler\n", "import torch.optim as optim\n", "from torch.optim.lr_scheduler import ReduceLROnPlateau\n", "\n", "optimizer = optim.Adam(model.parameters(), lr=5e-5, weight_decay=1e-4) # L2 regularization\n", "criterion = nn.CrossEntropyLoss()\n", "\n", "# Learning rate scheduler with increased patience\n", "scheduler = ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=5)\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "a5f5ed9b-34d0-41b5-8c46-66a28a7a6d95", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch 1: Train Loss=0.8030, Val Loss=0.6054, Accuracy=55.88%\n", "Epoch 2: Train Loss=0.5283, Val Loss=0.4614, Accuracy=70.59%\n", "Epoch 3: Train Loss=0.4676, Val Loss=0.4071, Accuracy=67.65%\n", "Epoch 4: Train Loss=0.4014, Val Loss=0.3437, Accuracy=79.41%\n", "Epoch 5: Train Loss=0.3075, Val Loss=0.4189, Accuracy=70.59%\n", "Epoch 6: Train Loss=0.2280, Val Loss=0.4556, Accuracy=70.59%\n", "Epoch 7: Train Loss=0.2089, Val Loss=0.4277, Accuracy=76.47%\n", "Epoch 8: Train Loss=0.1300, Val Loss=0.3871, Accuracy=76.47%\n", "Epoch 9: Train Loss=0.1979, Val Loss=0.4261, Accuracy=73.53%\n", "Epoch 10: Train Loss=0.1126, Val Loss=0.4501, Accuracy=76.47%\n", "Epoch 11: Train Loss=0.1359, Val Loss=0.3841, Accuracy=79.41%\n", "Epoch 12: Train Loss=0.0813, Val Loss=0.3953, Accuracy=79.41%\n", "Epoch 13: Train Loss=0.0825, Val Loss=0.3310, Accuracy=79.41%\n", "Epoch 14: Train Loss=0.1268, Val Loss=0.4192, Accuracy=82.35%\n", "Epoch 15: Train Loss=0.0658, Val Loss=0.4796, Accuracy=73.53%\n", "Epoch 16: Train Loss=0.0567, Val Loss=0.5067, Accuracy=76.47%\n", "Epoch 17: Train Loss=0.0444, Val Loss=0.3993, Accuracy=79.41%\n", "Epoch 18: Train Loss=0.0668, Val Loss=0.4695, Accuracy=73.53%\n", "Epoch 19: Train Loss=0.0308, Val Loss=0.4031, Accuracy=79.41%\n", "Epoch 20: Train Loss=0.0271, Val Loss=0.3735, Accuracy=82.35%\n" ] } ], "source": [ "# 4. Training Loop with Scheduler and Regularization\n", "epochs = 20\n", "for epoch in range(epochs):\n", " model.train()\n", " total_loss = 0\n", " for imgs, labels in train_loader:\n", " imgs, labels = imgs.to(device), labels.to(device)\n", " optimizer.zero_grad()\n", " logits = model(imgs).logits\n", " loss = criterion(logits, labels)\n", " loss.backward()\n", " optimizer.step()\n", " total_loss += loss.item()\n", "\n", " # Validation\n", " model.eval()\n", " val_loss, correct, total = 0, 0, 0\n", " with torch.no_grad():\n", " for imgs, labels in val_loader:\n", " imgs, labels = imgs.to(device), labels.to(device)\n", " logits = model(imgs).logits\n", " val_loss += criterion(logits, labels).item()\n", " preds = logits.argmax(dim=1)\n", " correct += (preds == labels).sum().item()\n", " total += labels.size(0)\n", "\n", " scheduler.step(val_loss / len(val_loader)) # Adjust learning rate\n", "\n", " print(f\"Epoch {epoch+1}: Train Loss={total_loss/len(train_loader):.4f}, \"\n", " f\"Val Loss={val_loss/len(val_loader):.4f}, Accuracy={correct/total:.2%}\")\n" ] }, { "cell_type": "code", "execution_count": null, "id": "c0b0f62a-d8cf-4b1b-92a0-a018f57711bb", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 8, "id": "3d773ae0-3d03-411a-a876-349947fa7999", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['./preprocessor_config.json']" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 4. Save Fine-Tuned Model\n", "model.save_pretrained(\"./\")\n", "processor.save_pretrained(\"./\")" ] }, { "cell_type": "code", "execution_count": 9, "id": "2945b482-c7a7-4105-9b1e-33df1955c551", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Likelihood of Comic Sans: 99.80%\n" ] } ], "source": [ "# 5. Inference Example: Test on a Single Image\n", "from PIL import Image # Ensure PIL is imported\n", "import matplotlib.pyplot as plt\n", "\n", "# Load and display the image\n", "image_path = \"./data/comic/test_sample.png\" # Replace with the path to your test image\n", "image = Image.open(image_path).convert(\"RGB\") # Open and convert the image to RGB\n", "\n", "# Display the image in Jupyter Notebook\n", "plt.imshow(image)\n", "plt.axis('off') # Turn off axes\n", "plt.title(\"Test Image\")\n", "plt.show()\n", "\n", "# Preprocess the image for the model\n", "inputs = processor(images=image, return_tensors=\"pt\").to(device)\n", "\n", "# Run inference\n", "model.eval()\n", "with torch.no_grad():\n", " outputs = model(**inputs).logits\n", " probs = torch.softmax(outputs, dim=-1)\n", " comic_prob = probs[0][1].item() # Class index 1 for \"Comic Sans\"\n", "\n", "# Print likelihood of Comic Sans\n", "print(f\"Likelihood of Comic Sans: {comic_prob:.2%}\")\n" ] }, { "cell_type": "code", "execution_count": null, "id": "9fff22a6-d1f3-4a2e-bc89-ccfa8796346a", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "2858a894-cc11-4d06-81a6-d7e82fa3d2e0", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.5" } }, "nbformat": 4, "nbformat_minor": 5 }