cnn-vit-transformer-deepfake.ipynb

{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.11.11","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"gpu","dataSources":[],"dockerImageVersionId":31011,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load\n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n\n# Input data files are available in the read-only \"../input/\" directory\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        print(os.path.join(dirname, filename))\n\n# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true,"execution":{"iopub.status.busy":"2025-04-15T23:37:17.911488Z","iopub.execute_input":"2025-04-15T23:37:17.912289Z","iopub.status.idle":"2025-04-15T23:37:17.917565Z","shell.execute_reply.started":"2025-04-15T23:37:17.912246Z","shell.execute_reply":"2025-04-15T23:37:17.916600Z"}},"outputs":[],"execution_count":23},{"cell_type":"code","source":"import os\nimport numpy as np\nfrom PIL import Image\nfrom collections import Counter\nimport matplotlib.pyplot as plt  # at top of file\n\n\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nfrom torch.utils.data import Dataset, DataLoader\n\nimport torchvision.transforms as transforms\n\n# Hugging Face dataset library\nfrom datasets import load_dataset\n\nimport timm\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-04-15T23:37:44.581681Z","iopub.execute_input":"2025-04-15T23:37:44.582473Z","iopub.status.idle":"2025-04-15T23:37:44.587163Z","shell.execute_reply.started":"2025-04-15T23:37:44.582444Z","shell.execute_reply":"2025-04-15T23:37:44.586251Z"}},"outputs":[],"execution_count":28},{"cell_type":"code","source":"# -------------------------------\n# Dataset Wrapper\n# -------------------------------\nclass DeepfakeDataset(Dataset):\n    \"\"\"\n    A custom Dataset wrapper for deepfake images.\n    It assumes that the HF dataset has keys \"image\" and \"label\".\n    \"\"\"\n    def __init__(self, hf_dataset, transform=None):\n        self.hf_dataset = hf_dataset\n        self.transform = transform\n\n    def __len__(self):\n        return len(self.hf_dataset)\n\n    def __getitem__(self, idx):\n        # Get the image and its label from the Hugging Face dataset\n        # (modify keys if needed based on the actual dataset structure)\n        sample = self.hf_dataset[idx]\n        image = sample['image']\n        # Convert the image to a PIL Image if it is not one\n        if not isinstance(image, Image.Image):\n            image = Image.fromarray(image)\n        label = sample['label']  # assuming labels are stored as 'label'\n        if self.transform:\n            image = self.transform(image)\n        return image, label\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-04-15T23:37:48.588239Z","iopub.execute_input":"2025-04-15T23:37:48.588512Z","iopub.status.idle":"2025-04-15T23:37:48.594462Z","shell.execute_reply.started":"2025-04-15T23:37:48.588495Z","shell.execute_reply":"2025-04-15T23:37:48.593558Z"}},"outputs":[],"execution_count":29},{"cell_type":"code","source":"# -------------------------------\n# Transformations for different model inputs\n# -------------------------------\n# For Model A and Model B, we use small images (50x50)\ntransform_small = transforms.Compose([\n    transforms.Resize((50, 50)),\n    transforms.ToTensor(),\n    transforms.Normalize(mean=[0.5]*3, std=[0.5]*3)\n])\n\n# For Model C, we use larger images (224x224)\ntransform_large = transforms.Compose([\n    transforms.Resize((224, 224)),\n    transforms.ToTensor(),\n    transforms.Normalize(mean=[0.5]*3, std=[0.5]*3)\n])","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-04-15T23:37:54.553741Z","iopub.execute_input":"2025-04-15T23:37:54.554079Z","iopub.status.idle":"2025-04-15T23:37:54.559777Z","shell.execute_reply.started":"2025-04-15T23:37:54.553992Z","shell.execute_reply":"2025-04-15T23:37:54.558844Z"}},"outputs":[],"execution_count":30},{"cell_type":"markdown","source":"# -------------------------------\n# Model Definitions\n# -------------------------------\n","metadata":{}},{"cell_type":"code","source":"\n# --- Model A: CNN-based network for eye and nose regions (12 layers) ---\nclass ModelA(nn.Module):\n    def __init__(self, num_classes=2):\n        super(ModelA, self).__init__()\n        # Three convolutional blocks, each with 2 conv layers + BN, ReLU, pooling and dropout\n        self.block1 = nn.Sequential(\n            nn.Conv2d(3, 32, kernel_size=3, padding=1),\n            nn.ReLU(),\n            nn.BatchNorm2d(32),\n            nn.Conv2d(32, 32, kernel_size=3, padding=1),\n            nn.ReLU(),\n            nn.MaxPool2d(kernel_size=2),\n            nn.Dropout(0.3)\n        )\n        self.block2 = nn.Sequential(\n            nn.Conv2d(32, 64, kernel_size=3, padding=1),\n            nn.ReLU(),\n            nn.BatchNorm2d(64),\n            nn.Conv2d(64, 64, kernel_size=3, padding=1),\n            nn.ReLU(),\n            nn.MaxPool2d(kernel_size=2),\n            nn.Dropout(0.3)\n        )\n        self.block3 = nn.Sequential(\n            nn.Conv2d(64, 128, kernel_size=3, padding=1),\n            nn.ReLU(),\n            nn.BatchNorm2d(128),\n            nn.Conv2d(128, 128, kernel_size=3, padding=1),\n            nn.ReLU(),\n            nn.MaxPool2d(kernel_size=2),\n            nn.Dropout(0.3)\n        )\n        # After three blocks, feature map size for 50x50 input: 50 -> 25 -> ~12 -> ~6\n        self.classifier = nn.Sequential(\n            nn.Flatten(),\n            nn.Linear(128 * 6 * 6, 512),\n            nn.ReLU(),\n            nn.Dropout(0.3),\n            nn.Linear(512, num_classes)\n        )\n\n    def forward(self, x):\n        x = self.block1(x)\n        x = self.block2(x)\n        x = self.block3(x)\n        x = self.classifier(x)\n        return x\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-04-15T23:37:58.551963Z","iopub.execute_input":"2025-04-15T23:37:58.552765Z","iopub.status.idle":"2025-04-15T23:37:58.560447Z","shell.execute_reply.started":"2025-04-15T23:37:58.552738Z","shell.execute_reply":"2025-04-15T23:37:58.559543Z"}},"outputs":[],"execution_count":31},{"cell_type":"code","source":"\n# --- Model B: Simpler CNN-based network (6 layers) ---\nclass ModelB(nn.Module):\n    def __init__(self, num_classes=2):\n        super(ModelB, self).__init__()\n        # A lighter CNN architecture: three conv layers with pooling and dropout\n        self.features = nn.Sequential(\n            nn.Conv2d(3, 32, kernel_size=3, padding=1),\n            nn.ReLU(),\n            nn.MaxPool2d(2),\n            nn.Dropout(0.3),\n\n            nn.Conv2d(32, 64, kernel_size=3, padding=1),\n            nn.ReLU(),\n            nn.MaxPool2d(2),\n            nn.Dropout(0.3),\n\n            nn.Conv2d(64, 128, kernel_size=3, padding=1),\n            nn.ReLU(),\n            nn.MaxPool2d(2),\n            nn.Dropout(0.3)\n        )\n        self.classifier = nn.Sequential(\n            nn.Flatten(),\n            nn.Linear(128 * 6 * 6, 512),\n            nn.ReLU(),\n            nn.Dropout(0.3),\n            nn.Linear(512, num_classes)\n        )\n\n    def forward(self, x):\n        x = self.features(x)\n        x = self.classifier(x)\n        return x","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-04-15T23:38:02.629928Z","iopub.execute_input":"2025-04-15T23:38:02.630548Z","iopub.status.idle":"2025-04-15T23:38:02.637046Z","shell.execute_reply.started":"2025-04-15T23:38:02.630525Z","shell.execute_reply":"2025-04-15T23:38:02.636062Z"}},"outputs":[],"execution_count":32},{"cell_type":"code","source":"# --- Model C: CNN + ViT based network for the entire face ---\nclass ModelC(nn.Module):\n    def __init__(self, num_classes=2):\n        super(ModelC, self).__init__()\n        # Feature learning (FL) module: a deep CNN.\n        # For demonstration, we use a simpler CNN here.\n        self.cnn_feature_extractor = nn.Sequential(\n            nn.Conv2d(3, 64, kernel_size=3, padding=1),\n            nn.ReLU(),\n            nn.MaxPool2d(2),\n            nn.Conv2d(64, 128, kernel_size=3, padding=1),\n            nn.ReLU(),\n            nn.MaxPool2d(2),\n            nn.Conv2d(128, 256, kernel_size=3, padding=1),\n            nn.ReLU(),\n            nn.MaxPool2d(2)\n        )\n        # Assume feature map size is reduced appropriately (for 224x224, it becomes roughly 28x28)\n        # Now use a vision transformer module from the timm library.\n        # Note: You may need to install timm (pip install timm).\n        self.vit = timm.create_model('vit_base_patch16_224', pretrained=True)\n        # Replace the head of ViT to match our number of classes.\n        in_features = self.vit.head.in_features\n        self.vit.head = nn.Linear(in_features, num_classes)\n\n    def forward(self, x):\n        # Extract lower-level features (optional fusion)\n        features = self.cnn_feature_extractor(x)\n        # For this demonstration, we are feeding the original image to vit.\n        # In a more advanced implementation, you can fuse the CNN features with ViT.\n        out = self.vit(x)\n        return out\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-04-15T23:38:06.977377Z","iopub.execute_input":"2025-04-15T23:38:06.977681Z","iopub.status.idle":"2025-04-15T23:38:06.984796Z","shell.execute_reply.started":"2025-04-15T23:38:06.977659Z","shell.execute_reply":"2025-04-15T23:38:06.983917Z"}},"outputs":[],"execution_count":33},{"cell_type":"markdown","source":"# -------------------------------\n# Training and Evaluation Functions\n# -------------------------------","metadata":{}},{"cell_type":"code","source":"\ndef train_model(model, dataloader, criterion, optimizer, device, num_epochs=5):\n    model.train()\n    loss_history = []\n    acc_history  = []\n    for epoch in range(num_epochs):\n        running_loss = 0.0\n        correct = 0\n        total = 0\n        for inputs, labels in dataloader:\n            inputs, labels = inputs.to(device), labels.to(device)\n            optimizer.zero_grad()\n            outputs = model(inputs)\n            loss = criterion(outputs, labels)\n            loss.backward()\n            optimizer.step()\n\n            running_loss += loss.item() * inputs.size(0)\n            _, preds = torch.max(outputs, 1)\n            correct += (preds == labels).sum().item()\n            total   += labels.size(0)\n\n        epoch_loss = running_loss / total\n        epoch_acc  = correct / total\n        loss_history.append(epoch_loss)\n        acc_history.append(epoch_acc)\n        print(f\"Epoch {epoch+1}/{num_epochs} — Loss: {epoch_loss:.4f}, Acc: {epoch_acc:.4f}\")\n\n    return model, loss_history, acc_history\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-04-15T23:38:10.740265Z","iopub.execute_input":"2025-04-15T23:38:10.740561Z","iopub.status.idle":"2025-04-15T23:38:10.747783Z","shell.execute_reply.started":"2025-04-15T23:38:10.740540Z","shell.execute_reply":"2025-04-15T23:38:10.746836Z"}},"outputs":[],"execution_count":34},{"cell_type":"code","source":"def evaluate_model(model, dataloader, device):\n    model.eval()\n    preds_all = []\n    labels_all = []\n    with torch.no_grad():\n        for inputs, labels in dataloader:\n            inputs = inputs.to(device)\n            outputs = model(inputs)\n            _, preds = torch.max(outputs, 1)\n            preds_all.extend(preds.cpu().numpy())\n            labels_all.extend(labels.numpy())\n    return np.array(preds_all), np.array(labels_all)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-04-15T23:38:18.833911Z","iopub.execute_input":"2025-04-15T23:38:18.834258Z","iopub.status.idle":"2025-04-15T23:38:18.840470Z","shell.execute_reply.started":"2025-04-15T23:38:18.834234Z","shell.execute_reply":"2025-04-15T23:38:18.839597Z"}},"outputs":[],"execution_count":36},{"cell_type":"code","source":"def majority_vote(predictions_list):\n    \"\"\"Combine predictions (list of numpy arrays) via majority voting.\"\"\"\n    # predictions_list should be a list of arrays with same length.\n    predictions_list = np.array(predictions_list)  # shape: [n_models, n_samples]\n    final_preds = []\n    for preds in predictions_list.T:\n        # Compute the majority vote for each sample.\n        vote = Counter(preds).most_common(1)[0][0]\n        final_preds.append(vote)\n    return np.array(final_preds)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-04-15T23:38:21.265259Z","iopub.execute_input":"2025-04-15T23:38:21.265774Z","iopub.status.idle":"2025-04-15T23:38:21.270920Z","shell.execute_reply.started":"2025-04-15T23:38:21.265750Z","shell.execute_reply":"2025-04-15T23:38:21.270068Z"}},"outputs":[],"execution_count":37},{"cell_type":"code","source":"def main():\n    # Check device\n    device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n    print(\"Using device:\", device)\n\n    # -------------------------------\n    # Load the dataset using Hugging Face datasets\n    # -------------------------------\n    hf_dataset = load_dataset('Hemg/deepfake-and-real-images', split=\"train\")\n    # For demonstration, use a subset (e.g., first 1000 samples)\n\n    # -------------------------------\n    # Create PyTorch Datasets for different input sizes\n    # -------------------------------\n    dataset_small = DeepfakeDataset(hf_dataset, transform=transform_small)\n    dataset_large = DeepfakeDataset(hf_dataset, transform=transform_large)\n    \n    # Split datasets into train and test (80/20 split)\n    n_total = len(dataset_small)\n    n_train = int(0.8 * n_total)\n    n_test = n_total - n_train\n    train_small, test_small = torch.utils.data.random_split(dataset_small, [n_train, n_test])\n    train_large, test_large = torch.utils.data.random_split(dataset_large, [n_train, n_test])\n\n    train_loader_small = DataLoader(train_small, batch_size=32, shuffle=True, num_workers=2)\n    test_loader_small = DataLoader(test_small, batch_size=32, shuffle=False, num_workers=2)\n\n    train_loader_large = DataLoader(train_large, batch_size=32, shuffle=True, num_workers=2)\n    test_loader_large = DataLoader(test_large, batch_size=32, shuffle=False, num_workers=2)\n\n    # -------------------------------\n    # Initialize models, loss function, and optimizers\n    # -------------------------------\n    num_classes = 2\n    modelA = ModelA(num_classes=num_classes).to(device)\n    modelB = ModelB(num_classes=num_classes).to(device)\n    modelC = ModelC(num_classes=num_classes).to(device)\n\n    criterion = nn.CrossEntropyLoss()\n\n    optimizerA = optim.Adam(modelA.parameters(), lr=1e-4)\n    optimizerB = optim.Adam(modelB.parameters(), lr=1e-4)\n    optimizerC = optim.Adam(modelC.parameters(), lr=1e-4)\n\n    print(\"Training Model A (CNN-based - Model A, 12 layers, small images)...\")\n    modelA, lossA, accA = train_model(modelA, train_loader_small, criterion, optimizerA, device, num_epochs=10)\n\n    print(\"Training Model B (Simpler CNN-based - Model B, small images)...\")\n    modelB, lossB, accB = train_model(modelB, train_loader_small, criterion, optimizerB, device, num_epochs=10)\n\n    print(\"Training Model C (CNN + ViT based - large images)...\")\n    modelC, lossC, accC = train_model(modelC, train_loader_large, criterion, optimizerC, device, num_epochs=10)\n\n    # After training all three:\n    epochs = list(range(1, 11))\n\n    plt.figure()\n    plt.plot(epochs, lossA, label='Model A')\n    plt.plot(epochs, lossB, label='Model B')\n    plt.plot(epochs, lossC, label='Model C')\n    plt.title('Training Loss vs. Epochs')\n    plt.xlabel('Epoch')\n    plt.ylabel('Loss')\n    plt.legend()\n    plt.show()\n\n    plt.figure()\n    plt.plot(epochs, accA, label='Model A')\n    plt.plot(epochs, accB, label='Model B')\n    plt.plot(epochs, accC, label='Model C')\n    plt.title('Training Accuracy vs. Epochs')\n    plt.xlabel('Epoch')\n    plt.ylabel('Accuracy')\n    plt.legend()\n    plt.show()\n\n    # -------------------------------\n    # Evaluate models on the test set\n    # -------------------------------\n    preds_A, labels = evaluate_model(modelA, test_loader_small, device)\n    preds_B, _ = evaluate_model(modelB, test_loader_small, device)\n    preds_C, _ = evaluate_model(modelC, test_loader_large, device)  # using large images for model C\n\n    # -------------------------------\n    # Ensemble: Majority Voting\n    # -------------------------------\n    # Ensure predictions arrays have the same length.\n    # (Here, we assume that test loaders are synchronized; otherwise, adjust accordingly.)\n    predictions = majority_vote([preds_A, preds_B, preds_C])\n    accuracy = np.mean(predictions == labels)\n    print(f\"Ensemble (Majority Voting) Test Accuracy: {accuracy * 100:.2f}%\")\n\n    from sklearn.metrics import confusion_matrix, classification_report\n\n    # ... after predictions = majority_vote(...)\n    accuracy = np.mean(predictions == labels)\n    print(f\"Ensemble Test Accuracy: {accuracy:.4f}\")\n\n    # Confusion matrix\n    cm = confusion_matrix(labels, predictions)\n    print(\"Confusion Matrix:\\n\", cm)\n\n    # Detailed metrics\n    print(\"Classification Report:\\n\",\n      classification_report(labels, predictions, target_names=['Real','Fake']))\n\n    plt.figure()\n    plt.imshow(cm, interpolation='nearest')\n    plt.title('Ensemble Confusion Matrix')\n    plt.xlabel('Predicted')\n    plt.ylabel('Actual')\n    plt.xticks([0,1], ['Real','Fake'])\n    plt.yticks([0,1], ['Real','Fake'])\n    for i in range(2):\n        for j in range(2):\n            plt.text(j, i, cm[i,j], ha='center', va='center')\n    plt.show()\n\n\n    torch.save(modelA.state_dict(), 'modelA.pth')\n    torch.save(modelB.state_dict(), 'modelB.pth')\n    torch.save(modelC.state_dict(), 'modelC.pth')\n\n    # Optionally save the entire ensemble config:\n    import json\n    with open('ensemble_config.json','w') as f:\n        json.dump({\n        \"models\": [\"modelA.pth\",\"modelB.pth\",\"modelC.pth\"],\n        \"accuracy\": accuracy\n        }, f)\n\nif __name__ == \"__main__\":\n    main()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-04-15T23:40:09.081763Z","iopub.execute_input":"2025-04-15T23:40:09.082302Z","iopub.status.idle":"2025-04-16T08:30:28.702175Z","shell.execute_reply.started":"2025-04-15T23:40:09.082271Z","shell.execute_reply":"2025-04-16T08:30:28.701482Z"}},"outputs":[{"name":"stdout","text":"Using device: cuda\nTraining Model A (CNN-based - Model A, 12 layers, small images)...\nEpoch 1/10 — Loss: 0.3871, Acc: 0.8163\nEpoch 2/10 — Loss: 0.2458, Acc: 0.8953\nEpoch 3/10 — Loss: 0.1972, Acc: 0.9184\nEpoch 4/10 — Loss: 0.1662, Acc: 0.9317\nEpoch 5/10 — Loss: 0.1490, Acc: 0.9395\nEpoch 6/10 — Loss: 0.1339, Acc: 0.9463\nEpoch 7/10 — Loss: 0.1236, Acc: 0.9505\nEpoch 8/10 — Loss: 0.1151, Acc: 0.9542\nEpoch 9/10 — Loss: 0.1083, Acc: 0.9565\nEpoch 10/10 — Loss: 0.1022, Acc: 0.9590\nTraining Model B (Simpler CNN-based - Model B, small images)...\nEpoch 1/10 — Loss: 0.4825, Acc: 0.7608\nEpoch 2/10 — Loss: 0.3833, Acc: 0.8236\nEpoch 3/10 — Loss: 0.3323, Acc: 0.8504\nEpoch 4/10 — Loss: 0.2963, Acc: 0.8694\nEpoch 5/10 — Loss: 0.2692, Acc: 0.8823\nEpoch 6/10 — Loss: 0.2499, Acc: 0.8925\nEpoch 7/10 — Loss: 0.2330, Acc: 0.9000\nEpoch 8/10 — Loss: 0.2214, Acc: 0.9063\nEpoch 9/10 — Loss: 0.2106, Acc: 0.9113\nEpoch 10/10 — Loss: 0.2016, Acc: 0.9157\nTraining Model C (CNN + ViT based - large images)...\nEpoch 1/10 — Loss: 0.1301, Acc: 0.9477\nEpoch 2/10 — Loss: 0.0874, Acc: 0.9659\nEpoch 3/10 — Loss: 0.0713, Acc: 0.9719\nEpoch 4/10 — Loss: 0.0612, Acc: 0.9755\nEpoch 5/10 — Loss: 0.0547, Acc: 0.9785\nEpoch 6/10 — Loss: 0.0483, Acc: 0.9814\nEpoch 7/10 — Loss: 0.0439, Acc: 0.9826\nEpoch 8/10 — Loss: 0.0402, Acc: 0.9842\nEpoch 9/10 — Loss: 0.0361, Acc: 0.9859\nEpoch 10/10 — Loss: 0.5087, Acc: 0.7173\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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\n"},"metadata":{}},{"name":"stdout","text":"Ensemble (Majority Voting) Test Accuracy: 94.87%\nEnsemble Test Accuracy: 0.9487\nConfusion Matrix:\n [[17778  1237]\n [  714 18338]]\nClassification Report:\n               precision    recall  f1-score   support\n\n        Real       0.96      0.93      0.95     19015\n        Fake       0.94      0.96      0.95     19052\n\n    accuracy                           0.95     38067\n   macro avg       0.95      0.95      0.95     38067\nweighted avg       0.95      0.95      0.95     38067\n\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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\n"},"metadata":{}}],"execution_count":41}]}