diff --git a/tutorials/dna-imaging/Notebooks/Simulation_of_DNA_chain_and_Res_Unet_final.ipynb b/tutorials/dna-imaging/Notebooks/Simulation_of_DNA_chain_and_Res_Unet_final.ipynb new file mode 100644 index 0000000..0ffaa4a --- /dev/null +++ b/tutorials/dna-imaging/Notebooks/Simulation_of_DNA_chain_and_Res_Unet_final.ipynb @@ -0,0 +1,27463 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cell_md_title", + "metadata": { + "id": "cell_md_title" + }, + "source": [ + "# Simulation of 'DNA chains on a substrate imaged via AFM'\n", + "**This notebook is intended to create simulations of DNA chain relaxation on a substrate imaged via AFM. By simulating physical relaxation and electrostatic attraction between a DNA chain and the substrate it allows users to generate high fidelity data.**\n", + "\n", + "This notebook generates a complete dataset stored within user defined directory `OUT_DIR`, primarily consisting of Synthetic AFM Images saved as `.npy` raw heightmap data (incorporating realistic noise from `.spm` blanks or PSD models) and optional `.png` files for quick visual inspection.\n", + "\n", + " To support machine learning workflows, the pipeline produces DNA Segmentation Masks in `.npy` format for pixel-wise background separation, alongside specialized Crossing Detection Masks that use Gaussian-weighted targets to highlight molecular intersections. Comprehensive Metadata for every sample, including bead counts and mechanical parameters, is saved in `.csv` or `.json` files, all of which are indexed in a central **manifest.csv** that links each generated image to its corresponding ground-truth masks and input configurations.\n", + "\n", + "---\n", + "**Cell execution order:** run cells 1 → 12 in sequence. \n", + "Cells 1–9 define functions and globals. Cell 10 is the sanity check. Cell 11 is used for benchmarking the time for execution and generation of the dataset. Cell 12 generates the full dataset.\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github.com/Prakhar-Dutta/ASAP/blob/1b5cfc5173e1bed4e59575e6dd4724cb20682620/tutorial/Not_final_version_DNA_notebook%20(1).ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": 227, + "id": "glVt-o8bCqSu", + "metadata": { + "id": "glVt-o8bCqSu" + }, + "outputs": [], + "source": [ + "from __future__ import annotations\n", + "\n", + "# Uncomment codes in this cell if using Colab/Kaggle.\n", + "import os\n", + "from pathlib import Path\n", + "import re\n", + "import csv\n", + "import traceback\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import animation\n", + "from IPython.display import HTML, display\n", + "from typing import Any\n", + "# Image processing\n", + "from scipy.ndimage import (\n", + " gaussian_filter, grey_dilation, distance_transform_edt,\n", + " binary_dilation, median_filter, affine_transform, zoom\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "2nb1FTtFC_q0", + "metadata": { + "id": "2nb1FTtFC_q0" + }, + "source": [ + "# 1. Setting up the simulation: With or without molecular dynamics?\n", + "## 1.1. Imports\n", + "\n", + "This notebook allows two possible ways of building the simulated DNA chains; with or without the use of **coarse-grained molecular dynamics**. Molecular dynamics based simulations are computationally expensive, but provide closeness to real AFM imaging. For users who would like to use molecular dynamics, they would need to import all the libraries that will be necessary for simulation of the images." + ] + }, + { + "cell_type": "code", + "execution_count": 228, + "id": "cell_code_01", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cell_code_01", + "outputId": "c24440c9-88c5-4f0e-ffea-2637536132b4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: openmm[cuda12] in /opt/conda/lib/python3.11/site-packages (8.5.1)\n", + "Requirement already satisfied: numpy in /opt/conda/lib/python3.11/site-packages (from openmm[cuda12]) (1.26.4)\n", + "Requirement already satisfied: OpenMM-CUDA-12==8.5.1 in /opt/conda/lib/python3.11/site-packages (from openmm[cuda12]) (8.5.1)\n", + "Requirement already satisfied: nvidia-cuda-runtime-cu12 in /opt/conda/lib/python3.11/site-packages (from OpenMM-CUDA-12==8.5.1->openmm[cuda12]) (12.1.105)\n", + "Requirement already satisfied: nvidia-cuda-nvcc-cu12 in /opt/conda/lib/python3.11/site-packages (from OpenMM-CUDA-12==8.5.1->openmm[cuda12]) (12.9.86)\n", + "Requirement already satisfied: nvidia-cuda-nvrtc-cu12 in /opt/conda/lib/python3.11/site-packages (from OpenMM-CUDA-12==8.5.1->openmm[cuda12]) (12.1.105)\n", + "Requirement already satisfied: nvidia-cuda-cupti-cu12 in /opt/conda/lib/python3.11/site-packages (from OpenMM-CUDA-12==8.5.1->openmm[cuda12]) (12.1.105)\n", + "Requirement already satisfied: nvidia-cufft-cu12 in /opt/conda/lib/python3.11/site-packages (from OpenMM-CUDA-12==8.5.1->openmm[cuda12]) (11.0.2.54)\n" + ] + } + ], + "source": [ + "# Install dependencies (uncomment in a fresh environment / Colab)\n", + "# Chain generation mode\n", + "USE_MD = True # True → OpenMM Langevin dynamics\n", + " # False → fast 2-D persistent-walk (no OpenMM needed)\n", + "# Molecular dynamics\n", + "!pip3 install -q scipy matplotlib pillow\n", + "if USE_MD:\n", + " !pip3 install openmm[cuda12]\n", + "# change the cuda version\n", + "# depending on the CUDA version available on your system.\n", + "# Ensure that CUDA can be accessed by OpenMM when running locally.\n", + " import openmm\n", + " import openmm.unit as unit\n" + ] + }, + { + "cell_type": "markdown", + "id": "1oW9llw-imr1", + "metadata": { + "id": "1oW9llw-imr1" + }, + "source": [ + "## 1.2. Defining the variables\n", + "Here we define the variables that will be used for the generation of the images and the masks. The variables control how the images and their masks will appear at the end. For training a Machine learning network like a U-Net, all images need to be of a standard size and need reproducible properties. To generate the likeness of DNA chains from simulated data, we start with building a chain by using a random walk in 3D with some set parameters like number of beads, bond length and persistence bonds and to simulate chain relaxation on substrate we raise the chain to a certain height." + ] + }, + { + "cell_type": "code", + "execution_count": 242, + "id": "sSqadS02hzPe", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "sSqadS02hzPe", + "outputId": "1c71be52-13a0-44bf-fa0d-6fde02a62dad" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Output folder: /home/jovyan/dna_dataset_unnormalized_1000_4lengths_MD\n" + ] + } + ], + "source": [ + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# Global settings\n", + "#(these are the variables that need to be changed\n", + "# to change the appearance of the resulting images)\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "\n", + "# Dataset\n", + "OUT_DIR = \"dna_dataset_unnormalized_1000_4lengths_MD\"\n", + "# Name of the output directory that you would like to store your data in\n", + "N_SAMPLES = 1000\n", + "# Number of samples that will be generated\n", + "BASE_SEED = 1\n", + "# Seed for reproducibility\n", + "\n", + "# Image resolution\n", + "NX = 512\n", + "NY = 512\n", + "\n", + "# Ring + MD\n", + "N_BEADS = 90\n", + "# default bead count for vizualization via chain creation cell\n", + "BEAD_COUNTS = [70, 80, 90, 100]\n", + "# four chain lengths that will be created in the dataset\n", + "#(1 bead corresponds to 1nm which is roughly 4 base pairs)\n", + "BOND_LENGTH = 1.0\n", + "# distance between beads\n", + "PERSISTENCE_BONDS = 23.0\n", + "# used to determine the range of angles which the chain is allowed to turn\n", + "K_ANGLE = 12.0\n", + "# used to determine the angular stiffness during relaxation\n", + "# (higher means more stiffness)\n", + "BASE_Z = 5.0\n", + "# Height above the substrate that the chain starts at before relaxing\n", + "\n", + "ANGLE_STIFNESS_MULT = 0.4\n", + "# If USE_MD is False, then angle stiffness multiplier controls\n", + "# chain propogation through space\n", + "\n", + "# MD recording\n", + "N_FRAMES = 200\n", + "STEPS_PER_FRAME = 200\n", + "# Between every frame local energy minimization happens for\n", + "#the given number of steps\n", + "\n", + "# AFM rendering\n", + "\n", + "tip_radius = 1\n", + "# Please select the tip radius here (Ideal range is 1nm-5nm)\n", + "nm_per_px = 2\n", + "# Internal AFM render sampling in nm / pixel before downsampling\n", + "\n", + "AFM_KW = dict(\n", + " nx=NX, ny=NY,\n", + " dna_diameter_nm=2.0,\n", + " # mapping to physical values\n", + " tip_radius_nm=0.01*tip_radius,\n", + " # Scaling factor is applied for internal control to match\n", + " max_height_nm=6.0,\n", + " # Maximum height for the colorbar\n", + " target_nm_per_px=0.04*nm_per_px,\n", + " # Scaling factor (0.04) is applied for internal control\n", + " max_radius_px=96,\n", + " # upper limit for the size of the chain in pixels\n", + " radius_shrink_px=0.0,\n", + " # Set to 0 so that rendering can match physical values\n", + " final_blur_sigma_px=0.20,\n", + " # When changing tip radius and nm_per_px to observe the expected\n", + " apply_edge_taper=True,\n", + " # physical effect, remove the scaling factors (0.04) for\n", + " # tip_radius_nm and target_nm_per_px\n", + " taper_sigma_nm=0.45,\n", + " # and scale all other parameters accordingly.\n", + " taper_floor=0.10,\n", + " add_center_ridge=True,\n", + " ridge_sigma_nm=0.25,\n", + " # This controls width of center ridge\n", + " ridge_amp_nm=0.25,\n", + " # This controls height of center ridge\n", + " grain_nm=0.0,\n", + " # This adds more noise to the chain\n", + " grain_sigma_px=0.6,\n", + " enable_crossing_boost=True,\n", + " # To boost the height of the crossings\n", + " min_separation_beads=12,\n", + " # Distance to other chain segments to not boost indiscriminately\n", + " boost_window_beads=2,\n", + " # How many beads to boost the height for\n", + " guaranteed_offset_nm=1.0,\n", + " # How much to boost\n", + " boost_method=\"additive\",\n", + " # add to the height of beads being boosted\n", + " boost_profile=\"gaussian\",\n", + " # Height increase profile\n", + " boost_sigma_beads=None,\n", + " far_clip_nm=2.5,\n", + " # Clip bead heights for beads that are not part of a crossing\n", + " far_clip_window_beads=3,\n", + " # How many beads to clip the height for\n", + " return_crossing_info=True,\n", + " # To ensure that mask information is passed to other functions.\n", + " # Change to False if masks are not needed\n", + " return_masks=True,\n", + ")\n", + "\n", + "\n", + "#-------------------------------------\n", + "# DNA mask\n", + "DNA_MASK_DILATE_PX = 3\n", + "# Dilation of mask for better training\n", + "#-------------------------------------\n", + "\n", + "#---------------------------\n", + "# Crossing mask\n", + "CROSS_MIN_SEP_BEADS = 8\n", + "# Where to stop for the crossing calculation\n", + "CROSS_SIGMA_CENTER_PX = 2.0\n", + "# How many pixels make up the center of a crossing\n", + "CROSS_SIGMA_PERP_PX = 1.4\n", + "# Crossing coloring parameter (how many pixels to modulate for the crossing)\n", + "CROSS_CHAIN_EXTENT = 2.0\n", + "# For the chain weighting of the mask\n", + "CROSS_CENTER_WEIGHT = 1.5\n", + "# For the chain weighting of the mask (chain-weighted guassian)\n", + "CROSS_CHAIN_WEIGHT = 0.5\n", + "CROSS_CLIP_TO_DNA_MASK = False\n", + "#---------------------------\n", + "\n", + "#Checking if output directory will be created\n", + "os.makedirs(OUT_DIR, exist_ok=True)\n", + "for _sub in [\"images\", \"dna_masks\", \"cross_masks\", \"meta\"]:\n", + " os.makedirs(os.path.join(OUT_DIR, _sub), exist_ok=True)\n", + "\n", + "print(\"Output folder:\", os.path.abspath(OUT_DIR))" + ] + }, + { + "cell_type": "markdown", + "id": "-e3QvQzGlKYY", + "metadata": { + "id": "-e3QvQzGlKYY" + }, + "source": [ + "## 1.3. Noise\n", + "To add realistic noise to the images so that they closely resemble real AFM images, 2 options have been provided in this notebook.\n", + "\n", + "\n", + "1. For users that have access to AFM imaging setups and substrates, a **blank ``.spm``** file can be loaded into this enviroment. The blank file is a scan of the substrate **without** the sample of interest. The notebook will parse through the file and add the noise that would appear as if a DNA chain were imaged on that substrate, thus making the output dataset closer to real DNA if it were to be imaged on that setup and substrate.\n", + "2. For users that do not have access to AFM imaging setups or available blanks, noise can be generated through an ensemble of blanks that were imaged on nickel susbtrates and processed. The information of that noise is available as a Power spectral density noise model that is available in this repository. There are 3 noise synthesis models offered but *mean_full2d* is preferred and chosen as the default.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 230, + "id": "47h81smulGxd", + "metadata": { + "id": "47h81smulGxd" + }, + "outputs": [], + "source": [ + "#Noise\n", + "TARGET_NOISE_RMS_NM = 0.27\n", + "# This variable controls the height of the noise\n", + "# in nanometers and this is added to the final image\n", + "\n", + "\n", + "# Blank SPM noise\n", + "USE_BLANK_SPM_NOISE = True\n", + "USE_PLANE_REMOVE = True\n", + "# This flag is used to control plane tilt removal from the noise image\n", + "USE_LINE_FLATTEN = True\n", + "# This flag is used to control line flattening (median filtering)\n", + "# from the noise image\n", + "USE_BANDPASS_FILTER = True\n", + "# This flag is used to control bandpass filtering on the noise image\n", + "BLANK_SPM_PATH = \"20240411_blank_water.0_00000.spm\"\n", + "# optional; if missing/invalid, PSD fallback noise is used\n", + "# Change path when running locally. If using Colab, upload the file\n", + "\n", + "\n", + "# PSD-model fallback noise (used when blank .spm file is not available)\n", + "USE_PSD_NOISE_FALLBACK = True\n", + "MODEL_PATH = \"/content/psd_noise_model.npz\"\n", + "# Change path when running locally. If using Colab, upload the noise file\n", + "PSD_NOISE_METHOD = \"mean_full2d\"\n", + "# or \"lognormal_full2d\" / \"empirical_radial\"\n", + "PSD_NOISE_STD_SCALE = 2.0\n" + ] + }, + { + "cell_type": "markdown", + "id": "cell_md_02", + "metadata": { + "id": "cell_md_02" + }, + "source": [ + "# 2. Chain Creation (3-D Persistent Random Walk)\n", + "Now we start with creating the DNA chain. This is the topology of the chain before relaxation is performed using molecular dynamnics.\n", + "\n", + "The function `make_tangled_ring_initial` builds a closed polymer ring via a persistent random walk and enforces ring-closure.\n", + "\n", + "A 3-D plot is shown at the end of the cell so you can inspect the initial geometry immediately." + ] + }, + { + "cell_type": "code", + "execution_count": 231, + "id": "cell_code_02", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 607 + }, + "id": "cell_code_02", + "outputId": "1271afac-e3a9-4d53-8120-a9428866a15c" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def make_tangled_ring_initial(\n", + " seed: int,\n", + " n_beads: int = N_BEADS,\n", + " bond_length: float = BOND_LENGTH,\n", + " persistence_bonds: float = PERSISTENCE_BONDS,\n", + " base_z: float = BASE_Z,\n", + ")-> np.ndarray:\n", + " \"\"\"Generates a closed (ring) polymer with a persistent random-walk tangent.\n", + "\n", + " Each step rotates the current direction by a small random angle around a\n", + " perpendicular axis. Ring closure is enforced by linearly distributing\n", + " the end-to-end gap across all beads. The chain is then lifted to base_z\n", + " so it can relax down to the z=0 substrate during MD.\n", + "\n", + " Parameters\n", + " ----------\n", + " seed : int\n", + " random seed for reproducibility\n", + " n_beads : int, optional\n", + " number of beads in the polymer ring. Defaults to N_BEADS.\n", + " bond_length : float, optional\n", + " the distance between consecutive beads. Defaults to BOND_LENGTH.\n", + " persistence_bonds : float, optional\n", + " the number of beads used to enforce persistence length in the chain.\n", + " Defaults to PERSISTENCE_BONDS.\n", + " base_z : float, optional\n", + " the height to lift the chain above the substrate. Defaults to BASE_Z.\n", + "\n", + " Returns\n", + " -------\n", + " Returns a list of [coords] with shape (N, 3).\n", + "\n", + " \"\"\"\n", + "\n", + " rng = np.random.default_rng(int(seed))\n", + "\n", + " steps = np.zeros((n_beads, 3), dtype=np.float32)\n", + " #Initialization of vector for chain propogation\n", + " vec = np.array([1.0, 0.0, 0.0], dtype=np.float32)\n", + "\n", + " for k in range(n_beads):\n", + " dtheta = rng.normal(scale=np.sqrt(1.0 / persistence_bonds))\n", + " #choose an axis at random for chain propogation in 3D\n", + " axis = rng.normal(size=3).astype(np.float32)\n", + " # remove component along vec\n", + " axis -= axis.dot(vec) * vec\n", + " axis_norm = np.linalg.norm(axis)\n", + " # failsafe\n", + " if axis_norm < 1e-8:\n", + " axis = np.array([0.0, 0.0, 1.0], dtype=np.float32)\n", + " axis_norm = 1.0\n", + " axis /= axis_norm\n", + " # Calculating vector for chain propogation\n", + " vec = vec * np.cos(dtheta) + np.cross(axis, vec) * np.sin(dtheta)\n", + " vec /= np.linalg.norm(vec)\n", + " steps[k] = bond_length * vec\n", + "\n", + " coords = np.cumsum(steps, axis=0) # Coordinates for open chain\n", + "\n", + " # Enforce ring closure\n", + " closure_error = coords[-1] - coords[0]\n", + " # Based on the distance between first and last bead a\n", + " # closure error is propogated to all bead positions to form a closed chain\n", + " t = np.linspace(0, 1, n_beads, dtype=np.float32).reshape(-1, 1)\n", + " coords -= t * closure_error\n", + " coords -= coords.mean(axis=0)\n", + "\n", + " # Lift above substrate\n", + " # (z values are changed to lift the chain off the substrate)\n", + " coords[:, 2] += float(base_z)\n", + " return coords.astype(np.float32)\n", + "\n", + "\n", + "# ── Quick visualisation ──────────────────────────────────────────────────────\n", + "demo_coords = make_tangled_ring_initial(seed=43)\n", + "cc = np.vstack([demo_coords, demo_coords[0]]) # close the ring for plotting\n", + "\n", + "fig = plt.figure(figsize=(7, 6))\n", + "ax = fig.add_subplot(111, projection=\"3d\")\n", + "ax.plot(cc[:, 0], cc[:, 1], cc[:, 2], \"-o\", markersize=3, linewidth=1.2)\n", + "ax.scatter(cc[0, 0], cc[0, 1], cc[0, 2], color=\"red\",\n", + " s=60, zorder=5, label=\"bead 0\")\n", + "\n", + "# Draw substrate plane\n", + "xs = np.linspace(cc[:, 0].min(), cc[:, 0].max(), 2)\n", + "ys = np.linspace(cc[:, 1].min(), cc[:, 1].max(), 2)\n", + "X, Y = np.meshgrid(xs, ys)\n", + "ax.plot_surface(X, Y, np.zeros_like(X), alpha=0.15, color=\"cyan\")\n", + "\n", + "ax.set_xlabel(\"x (sim units)\"); ax.set_ylabel(\"y\"); ax.set_zlabel(\"z\")\n", + "ax.set_title(f\"Initial ring — seed 43, {len(demo_coords)} beads\")\n", + "ax.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "cell_md_03", + "metadata": { + "id": "cell_md_03" + }, + "source": [ + "# 3. Molecular Dynamics Relaxation\n", + "To accurately mimic chain relaxation on a substrate a coarse grained molecular dynamics simulation is performed using OpenMM (no water or other molecules simulated). If Molecular dynamics is not needed, please skip this cell.\n", + "\n", + "The function `run_md_relaxation` runs a Langevin-dynamics simulation in the overdampled regime via OpenMM.\n", + "Here we have added:\n", + "\n", + "1. Harmonic bonds\n", + "2. Bending-angle stiffness\n", + "3. A surface-attraction to cause chain relaxation\n", + "4. A hard-wall force to keep chain above substrate\n", + "5. A short-range WCA repulsion to ensure chain does not take non physical configurations\n", + "\n", + "The function then records `n_frames` snapshots which can be used for visualization." + ] + }, + { + "cell_type": "markdown", + "id": "wFFhsVZhqU8a", + "metadata": { + "id": "wFFhsVZhqU8a" + }, + "source": [ + "We start with testing the OpenMM installation (can be tricky at times)" + ] + }, + { + "cell_type": "code", + "execution_count": 232, + "id": "3NjBSwfAe4Mj", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3NjBSwfAe4Mj", + "outputId": "9ed84c26-7ee9-4552-dc85-cbed8551af08" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "OpenMM Version: 8.5.1\n", + "Git Revision: f7fa0c27c1f8d943c339d67b3bf22f026d0bd8b5\n", + "\n", + "There are 3 Platforms available:\n", + "\n", + "1 Reference - Successfully computed forces\n", + "2 CPU - Successfully computed forces\n", + "3 CUDA - Successfully computed forces\n", + "\n", + "Median difference in forces between platforms:\n", + "\n", + "Reference vs. CPU: 6.2949e-06\n", + "Reference vs. CUDA: 6.75876e-06\n", + "CPU vs. CUDA: 7.29567e-07\n", + "\n", + "All differences are within tolerance.\n" + ] + } + ], + "source": [ + "# Test the OpenMM installation before running the following cell\n", + "# to ensure that GPU acceleration will work\n", + "import openmm.testInstallation\n", + "\n", + "# Run the standard OpenMM installation test to check for CUDA/GPU support\n", + "try:\n", + " openmm.testInstallation.main()\n", + "except Exception as e:\n", + " print(f\"Test failed: {e}\")" + ] + }, + { + "cell_type": "markdown", + "id": "9XbRNS3TqbKH", + "metadata": { + "id": "9XbRNS3TqbKH" + }, + "source": [ + "And then once we are sure that OpenMM is correctly installed, we run the MD functions" + ] + }, + { + "cell_type": "code", + "execution_count": 233, + "id": "cell_code_03", + "metadata": { + "id": "cell_code_03" + }, + "outputs": [], + "source": [ + "def run_md_relaxation(\n", + " coords0: np.ndarray,\n", + " seed: int,\n", + " n_frames: int = N_FRAMES,\n", + " steps_per_frame: int = STEPS_PER_FRAME,\n", + ")-> list[np.ndarray]:\n", + " \"\"\"\n", + " Takes initial bead coordinates and runs Langevin dynamics using OpenMM\n", + "\n", + " This function uses the coordinates generated using the\n", + " `make_tangled_ring_initial` function to run a molecular dynamics\n", + " simulation. There are certain forces that are defined and applied to the\n", + " bead which are then resolved using OpenMM.\n", + " The forces applied are:\n", + " - Harmonic bonds + angle stiffness along the ring\n", + " - Surface attraction (linear in z) + hard wall at z = 0\n", + " - Short-range Weeks–Chandler–Andersen (WCA)\n", + " repulsion between non-bonded beads\n", + " Drift removal is also performed using OpenMM's CMMotionRemover.\n", + " The variable langevin integrator from OpenMM is used and the forces are\n", + " resolved for 'steps_per_frame' steps for every frame in n_frames.\n", + "\n", + " Parameters\n", + " ----------\n", + " coords0 : np.ndarray\n", + " The starting [x, y, z] coordinates of the polymer beads.\n", + " seed : int\n", + " Random seed for the Langevin integrator.\n", + " n_frames : int, optional\n", + " Number of frames to record during the simulation. Defaults to N_FRAMES.\n", + " steps_per_frame : int, optional\n", + " Number of integration steps to perform between recorded frames.\n", + " Defaults to STEPS_PER_FRAME.\n", + "\n", + " Returns\n", + " -------\n", + " A list of coordinate arrays of shape (num_beads, 3). The list contains\n", + " num_frames + 1 entries, where frame 0 is the pre-minimization geometry.\n", + "\n", + " Raises\n", + " ------\n", + " RuntimeError\n", + " If no OpenMM platform (CUDA, OpenCL, or CPU) could be initialised.\n", + "\n", + " Examples\n", + " --------\n", + " >>> frames = run_md_relaxation(_anim_coords0, seed=1, n_frames=N_FRAMES,\n", + " steps_per_frame=STEPS_PER_FRAME)\n", + " >>> print({len(frames), frames[0].shape})\n", + " {11, (100, 3)}\n", + "\n", + " \"\"\"\n", + "\n", + " coords0 = np.asarray(coords0, dtype=np.float32)\n", + " n = int(coords0.shape[0])\n", + "\n", + " # how big the bounding box for the molecular dynamics needs to be\n", + " extent = (coords0.max(axis=0) - coords0.min(axis=0)).max()\n", + " box = float(extent + 10.0)\n", + "\n", + "\n", + " # All lengths in nm, energies in kJ/mol.\n", + " BOLTZ_kJmol = 0.00831445 # kJ / (mol · K)\n", + " temperature = 1.0 # K (sets energy scale kT ≈ 0.0083 kJ/mol)\n", + " kT = BOLTZ_kJmol * temperature # kJ/mol\n", + " conlen = 1.0 # nm\n", + " mass_amu = 100.0 # Da per bead\n", + " collision_rate = 0.6 # ps⁻¹\n", + " error_tol = 0.005\n", + "\n", + " # ── Build system ─────────────────────────────────────────────────────────\n", + " system = openmm.System()\n", + " system.setDefaultPeriodicBoxVectors(\n", + " openmm.Vec3(box, 0, 0),\n", + " openmm.Vec3(0, box, 0),\n", + " openmm.Vec3(0, 0, box),\n", + " )\n", + " for _ in range(n):\n", + " system.addParticle(mass_amu)\n", + "\n", + " # Remove COM drift — applied every 50 steps\n", + " system.addForce(openmm.CMMotionRemover(10))\n", + " # To ensure CPU and GPU calculation are consistent\n", + " # (since GPU minimizations calculations can suffer from drift)\n", + "\n", + " # ── 1. Harmonic bonds ────────────────────────────────────────────────────\n", + "\n", + " # OpenMM HarmonicBondForce: E = (k/2)·(r − r0)² → k = kT / wiggle²\n", + " bond_L = BOND_LENGTH # nm\n", + " wiggle = 0.1 # nm (bondWiggleDistance)\n", + " k_bond = kT / (wiggle ** 2) # kJ/mol/nm²\n", + "\n", + " bond_force = openmm.HarmonicBondForce()\n", + " bond_force.setUsesPeriodicBoundaryConditions(True)\n", + " for i in range(n):\n", + " bond_force.addBond(i, (i + 1) % n, bond_L, k_bond)\n", + " system.addForce(bond_force)\n", + "\n", + " # ── 2. Bending (angle) stiffness ─────────────────────────────────────────\n", + " # E = kT · k_angle · (1 − cos(θ − π)) — equilibrium at θ = π (straight)\n", + " k_angle = K_ANGLE\n", + " angle_force = openmm.CustomAngleForce(\n", + " \"kT * kangle * (1 - cos(theta - 3.141592653589793))\"\n", + " )\n", + " angle_force.addGlobalParameter(\"kT\", kT)\n", + " angle_force.addGlobalParameter(\"kangle\", k_angle)\n", + " for i in range(n):\n", + " angle_force.addAngle((i - 1) % n, i, (i + 1) % n, [])\n", + " system.addForce(angle_force)\n", + "\n", + " # ── 3. Surface: linear attraction (z > 0) + harmonic hard wall (z < 0) ───\n", + " wall_expr = (\n", + " \"kT * (\"\n", + " \" F_pull * z * step(z) + \"\n", + " \" 0.5 * wallK * (z^2) * step(-z)\"\n", + " \")\"\n", + " )\n", + " wall_force = openmm.CustomExternalForce(wall_expr)\n", + " wall_force.addGlobalParameter(\"kT\", kT)\n", + " wall_force.addGlobalParameter(\"F_pull\", 9.0)\n", + " wall_force.addGlobalParameter(\"wallK\", 100.0)\n", + " for i in range(n):\n", + " wall_force.addParticle(i, [])\n", + " system.addForce(wall_force)\n", + "\n", + " # ── 4. WCA repulsion (repulsion between non-bonded pairs only) ───────────\n", + " rep_sigma = 1.6 * conlen # nm\n", + " rep_cutoff = 2.3 * conlen # nm\n", + " rep_expr = (\n", + " \"4*eps * ( (sig / (r + shift))^12 - (sig / (r + shift))^6 + 0.25 )\"\n", + " \"* step(cutoff - r);\"\n", + " \"cutoff = 2^(1.0/6.0) * sig\"\n", + " )\n", + " rep_force = openmm.CustomNonbondedForce(rep_expr)\n", + " rep_force.setNonbondedMethod(openmm.CustomNonbondedForce.CutoffPeriodic)\n", + " rep_force.setCutoffDistance(rep_cutoff)\n", + " rep_force.addGlobalParameter(\"eps\", 1.7 * kT)\n", + " rep_force.addGlobalParameter(\"sig\", rep_sigma)\n", + " rep_force.addGlobalParameter(\"shift\", 1e-8)\n", + " for i in range(n):\n", + " rep_force.addParticle([])\n", + " # exclude bonded neighbours\n", + " for i in range(n):\n", + " rep_force.addExclusion(i, (i + 1) % n)\n", + " system.addForce(rep_force)\n", + "\n", + " # ── Integrator ───────────────────────────────────────────────────────────\n", + " integrator = openmm.VariableLangevinIntegrator(temperature,\n", + " collision_rate, error_tol)\n", + " integrator.setRandomNumberSeed(int(seed))\n", + "\n", + " # ── Platform selection: OpenCL → CPU fallback ────────────────────────────\n", + " context = None\n", + " # OpenCL enables Mac users to be able to use GPU acceleration as well\n", + " for platform_name in (\"CUDA\",\"OpenCL\",\"CPU\"):\n", + " try:\n", + " platform = openmm.Platform.getPlatformByName(platform_name)\n", + " context = openmm.Context(system, integrator, platform)\n", + " print(f\"Using {platform_name} platform.\")\n", + " break\n", + " except openmm.OpenMMException as e:\n", + " print(f\" {platform_name} unavailable: {e}\")\n", + " except Exception as e:\n", + " print(f\" {platform_name} failed unexpectedly: {e}\")\n", + "\n", + " if context is None:\n", + " raise RuntimeError(\"No OpenMM platform could be initialised.\")\n", + "\n", + " # ── Set initial positions and box ────────────────────────────────────────\n", + " positions = [\n", + " openmm.Vec3(float(coords0[i, 0]),\n", + " float(coords0[i, 1]), float(coords0[i, 2]))\n", + " for i in range(n)\n", + " ]\n", + " context.setPositions(positions)\n", + " context.setPeriodicBoxVectors(\n", + " openmm.Vec3(box, 0, 0),\n", + " openmm.Vec3(0, box, 0),\n", + " openmm.Vec3(0, 0, box),\n", + " )\n", + "\n", + " # Capture the true initial geometry before any minimisation\n", + " # (just in case the chain reaches substrate even before the 1st frame)\n", + " frames = []\n", + " state = context.getState(getPositions=True)\n", + " pos = state.getPositions(asNumpy=True).value_in_unit(unit.nanometer)\n", + " frames.append(pos.copy())\n", + "\n", + " # Cap iterations\n", + " openmm.LocalEnergyMinimizer.minimize(context,\n", + " tolerance=50, maxIterations=200)\n", + "\n", + " # ── Record frames ────────────────────────────────────────────────────────\n", + " for _ in range(int(n_frames)):\n", + " integrator.step(int(steps_per_frame))\n", + " state = context.getState(getPositions=True)\n", + " pos = state.getPositions(asNumpy=True).value_in_unit(unit.nanometer)\n", + " frames.append(pos.copy())\n", + "\n", + " return frames # n_frames + 1 entries (frame 0 = initial geometry)" + ] + }, + { + "cell_type": "markdown", + "id": "Bx7_OzWRr-l3", + "metadata": { + "id": "Bx7_OzWRr-l3" + }, + "source": [ + "# 4. Non-MD chain generation\n", + "In case you would not like to use molecular dynamics to generate the chains, it is also possible to skip the molecular dynamics and just use a simple 2D persistent walk to generate the DNA chains. The chains generated by this method might have some non physical configurations but the properties of the function can be modulated to achieve desired results." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "yXs0I0akr948", + "metadata": { + "id": "yXs0I0akr948" + }, + "outputs": [], + "source": [ + "def make_ring_2d_persistent_initial(\n", + " seed: int,\n", + " n_beads: int,\n", + " bond_length: float = BOND_LENGTH, # From Cell 1\n", + " persistence_bonds: float = PERSISTENCE_BONDS, # From Cell 1\n", + " angle_stiffness_mult: float = ANGLE_STIFNESS_MULT, # From Cell 1\n", + " # Small Gaussian noise for Z\n", + " z_std: float = 0.08,\n", + " # Low altitude for \"deposited\" look\n", + " base_z: float = 0.2,\n", + " # Acts as a soft per-step cap\n", + " angle_limit: float = np.pi/2,\n", + ") -> list[np.ndarray]:\n", + " \"\"\"\n", + " Generate a closed 2D persistent ring and return it as [coords].\n", + "\n", + " The function builds a periodic sequence of turning angles, smooths the\n", + " sequence to suppress sharp corners, and enforces total turning to ensure\n", + " the tangent field is compatible with a closed loop. The resulting curve is\n", + " resampled by arc length to maintain uniform bead spacing.\n", + "\n", + " Parameters\n", + " ----------\n", + " seed : int\n", + " Random seed for reproducibility.\n", + " n_beads : int\n", + " Number of beads in the polymer ring.\n", + " bond_length : float, optional\n", + " The desired distance between consecutive beads.\n", + " Defaults to BOND_LENGTH.\n", + " persistence_bonds : float, optional\n", + " Stiffness parameter; larger values result in a smoother ring with\n", + " longer directional memory. Defaults to PERSISTENCE_BONDS.\n", + " angle_stiffness_mult : float, optional\n", + " Multiplier for angular fluctuations; larger values result in\n", + " smaller fluctuations. Defaults to ANGLE_STIFNESS_MULT.\n", + " z_std : float, optional\n", + " Standard deviation for the Gaussian noise applied to the z-axis.\n", + " Defaults to 0.08.\n", + " base_z : float, optional\n", + " The baseline altitude for the deposited coordinates. Defaults to 0.2.\n", + " angle_limit : float, optional\n", + " A soft cap on local turning increments (radians). Defaults to np.pi/2.\n", + "\n", + " Returns\n", + " -------\n", + " coords : np.ndarray\n", + " Array of shape (N, 3) containing the [x, y, z] coordinates\n", + "\n", + " Raises\n", + " ------\n", + " ValueError\n", + " If num_beads is less than 6 or if the generated ring has zero\n", + " contour length.\n", + "\n", + " Examples\n", + " --------\n", + " >>> coords = make_ring_2d_persistent_initial(seed=42)\n", + " >>> print(coords.shape)\n", + " (90, 3)\n", + "\n", + " \"\"\"\n", + "\n", + " rng = np.random.default_rng(int(seed))\n", + " n = int(n_beads)\n", + " if n < 6:\n", + " raise ValueError(\"n_beads must be at least\"\n", + " \"6 for a stable closed persistent ring.\")\n", + "\n", + " bond_length = float(bond_length)\n", + "\n", + " # ------------------------------------------------------------------\n", + " # 1) Build a periodic turning-angle process on the ring\n", + " # ------------------------------------------------------------------\n", + "\n", + " # larger persistence_bonds / angle_stiffness_mult => less angular noise\n", + " sigma_dtheta = (\n", + " np.sqrt(2.0 / max(float(persistence_bonds), 1.0))\n", + " / max(float(angle_stiffness_mult), 1e-6)\n", + " )\n", + "\n", + " # Raw local turning increments\n", + " dtheta = rng.normal(0.0, sigma_dtheta, size=n).astype(np.float64)\n", + " dtheta = np.clip(dtheta, -float(angle_limit), float(angle_limit))\n", + "\n", + " # Circular smoothing of turning increments to suppress sharp local corners.\n", + " # Stronger persistence / stiffness => broader smoothing.\n", + " smooth_width = int(np.clip(np.round(max(float(persistence_bonds), 1.0)\n", + " / 6.0), 1, 8))\n", + " if smooth_width > 0:\n", + " offsets = np.arange(-smooth_width, smooth_width + 1, dtype=np.float64)\n", + " kernel_sigma = max(smooth_width / 2.0, 1e-6)\n", + " kernel = np.exp(-0.5 * (offsets / kernel_sigma) ** 2)\n", + " kernel /= kernel.sum()\n", + "\n", + " dtheta_smooth = np.zeros_like(dtheta)\n", + " for shift, w in zip(offsets.astype(int), kernel):\n", + " dtheta_smooth += w * np.roll(dtheta, shift)\n", + " dtheta = dtheta_smooth\n", + "\n", + " # Enforce exact total turning of 2*pi for a closed planar ring.\n", + " # This avoids the nonphysical post hoc closure drift used before.\n", + " total_turn = dtheta.sum()\n", + " dtheta += (2.0 * np.pi - total_turn) / n\n", + "\n", + " # Re-clip gently after correction, then re-enforce total turning once more.\n", + " dtheta = np.clip(dtheta, -float(angle_limit), float(angle_limit))\n", + " dtheta += (2.0 * np.pi - dtheta.sum()) / n\n", + "\n", + " # ---------------------------------------------------------------------\n", + " # 2) Build periodic tangent angles and integrate to a dense closed path\n", + " # ---------------------------------------------------------------------\n", + " theta0 = rng.uniform(0.0, 2.0 * np.pi)\n", + " thetas = theta0 + np.cumsum(dtheta)\n", + "\n", + " # Use a dense piecewise-linear curve first; later resample uniformly.\n", + " tangents = np.stack([np.cos(thetas), np.sin(thetas)], axis=1)\n", + "\n", + " # Integrate unit-speed steps to get a provisional loop\n", + " xy = np.zeros((n, 2), dtype=np.float64)\n", + " xy[1:] = np.cumsum(tangents[:-1] * bond_length, axis=0)\n", + " end_error = (xy[-1] + tangents[-1] * bond_length) - xy[0]\n", + "\n", + " # Distribute closure correction through the bond vectors\n", + " bond_corr = end_error / n\n", + " bonds = tangents * bond_length - bond_corr[None, :]\n", + "\n", + " # Renormalize bond lengths back toward bond_length while keeping closure.\n", + " bond_norms = np.linalg.norm(bonds, axis=1)\n", + " good = bond_norms > 1e-12\n", + " bonds[good] *= (bond_length / bond_norms[good])[:, None]\n", + "\n", + " # Re-enforce closure after renormalization\n", + " bonds -= bonds.sum(axis=0, keepdims=True) / n\n", + "\n", + " # Reconstruct coordinates from corrected bonds\n", + " xy = np.zeros((n, 2), dtype=np.float64)\n", + " xy[1:] = np.cumsum(bonds[:-1], axis=0)\n", + "\n", + " # -----------------------------------------------------------------\n", + " # 3) Arc-length resample so bead spacing stays uniform and physical\n", + " # -----------------------------------------------------------------\n", + " closed_xy = np.vstack([xy, xy[0]])\n", + " seg = np.linalg.norm(np.diff(closed_xy, axis=0), axis=1)\n", + " s = np.concatenate([[0.0], np.cumsum(seg)])\n", + " total_len = s[-1]\n", + "\n", + " if total_len <= 1e-12:\n", + " raise ValueError(\"Degenerate ring generated;\"\n", + " \"total contour length is zero.\")\n", + "\n", + " target_s = np.linspace(0.0, total_len, n + 1)[:-1]\n", + "\n", + " x_resamp = np.interp(target_s, s, closed_xy[:, 0])\n", + " y_resamp = np.interp(target_s, s, closed_xy[:, 1])\n", + " xy = np.stack([x_resamp, y_resamp], axis=1)\n", + "\n", + " # Final contour-length normalization\n", + " # so mean bond length matches bond_length\n", + " final_bonds = np.roll(xy, -1, axis=0) - xy\n", + " mean_bond = np.mean(np.linalg.norm(final_bonds, axis=1))\n", + " if mean_bond > 1e-12:\n", + " xy *= (bond_length / mean_bond)\n", + "\n", + " # Center at origin\n", + " xy -= xy.mean(axis=0, keepdims=True)\n", + "\n", + " # ------------------------------------------------------------------\n", + " # 4) Assembly with preserved Gaussian z-noise logic\n", + " # ------------------------------------------------------------------\n", + " coords = np.zeros((n, 3), dtype=np.float32)\n", + " coords[:, 0] = xy[:, 0].astype(np.float32)\n", + " coords[:, 1] = xy[:, 1].astype(np.float32)\n", + " coords[:, 2] = rng.normal(loc=base_z,\n", + " scale=z_std, size=n).astype(np.float32)\n", + "\n", + " # Return as a list containing one frame to mimic run_md_relaxation output\n", + " return [coords]" + ] + }, + { + "cell_type": "markdown", + "id": "cell_md_04", + "metadata": { + "id": "cell_md_04" + }, + "source": [ + "# 5. MD Animation\n", + "Now we can visualize the Molecular dynamics simulation to see how the relaxation has worked.\n", + "\n", + "The function `show_md_animation` renders an interactive 3-D animation of MD frames in the notebook.\n", + "Running this cell will automatically generate and display the animation for a single deterministic chain (seed 0, default bead count)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "cell_code_04", + "metadata": { + "id": "cell_code_04" + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'np' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[1], line 2\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mshow_md_animation\u001b[39m(\n\u001b[1;32m----> 2\u001b[0m frames: \u001b[38;5;28mlist\u001b[39m[\u001b[43mnp\u001b[49m\u001b[38;5;241m.\u001b[39mndarray],\n\u001b[0;32m 3\u001b[0m interval_ms: \u001b[38;5;28mint\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m150\u001b[39m,\n\u001b[0;32m 4\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m 5\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 6\u001b[0m \u001b[38;5;124;03m Renders an in-notebook HTML5 animation of MD frames.\u001b[39;00m\n\u001b[0;32m 7\u001b[0m \n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 30\u001b[0m \n\u001b[0;32m 31\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m 33\u001b[0m frames \u001b[38;5;241m=\u001b[39m [np\u001b[38;5;241m.\u001b[39masarray(f, dtype\u001b[38;5;241m=\u001b[39mnp\u001b[38;5;241m.\u001b[39mfloat32) \u001b[38;5;28;01mfor\u001b[39;00m f \u001b[38;5;129;01min\u001b[39;00m frames]\n", + "\u001b[1;31mNameError\u001b[0m: name 'np' is not defined" + ] + } + ], + "source": [ + "def show_md_animation(\n", + " frames: list[np.ndarray],\n", + " interval_ms: int = 150,\n", + ") -> None:\n", + " \"\"\"\n", + " Renders an in-notebook HTML5 animation of MD frames.\n", + "\n", + " This function is used to visualize the molecular dynamics simulation\n", + " generated using the `run_md_relaxation` function.\n", + " A plane has been added for visualization purposes and the range of\n", + " absolute z values is also displayed.\n", + " This function is purely for visualisation and does not mutate any arrays.\n", + "\n", + " Parameters\n", + " ----------\n", + " frames : list\n", + " A list of coordinate arrays of shape (num_beads, 3).\n", + " interval_ms : int, optional\n", + " The time interval between frames in milliseconds. Defaults to 150.\n", + "\n", + " Returns\n", + " -------\n", + " None\n", + " The function calls `IPython.display.display` to render the\n", + " animation object directly in the notebook.\n", + "\n", + " Examples\n", + " --------\n", + " >>> show_md_animation(frames)\n", + "\n", + " \"\"\"\n", + "\n", + " frames = [np.asarray(f, dtype=np.float32) for f in frames]\n", + "\n", + " # Use only the first frame for x/y limits\n", + " # — avoids COM drift blowing the scale\n", + " first = frames[0]\n", + " xy_pad = 5.0\n", + " x_min, x_max = first[:, 0].min() - xy_pad, first[:, 0].max() + xy_pad\n", + " y_min, y_max = first[:, 1].min() - xy_pad, first[:, 1].max() + xy_pad\n", + "\n", + " # Clamp z: floor at -1 (just below substrate),\n", + " # ceiling from initial max + padding\n", + " z_min = -1.0\n", + " z_max = float(first[:, 2].max()) + 3.0\n", + "\n", + " x_plane = np.linspace(x_min, x_max, 2)\n", + " y_plane = np.linspace(y_min, y_max, 2)\n", + " X_plane, Y_plane = np.meshgrid(x_plane, y_plane)\n", + " Z_plane = np.zeros_like(X_plane)\n", + "\n", + " fig = plt.figure(figsize=(6, 6))\n", + " ax = fig.add_subplot(111, projection=\"3d\")\n", + "\n", + " def _set_axes():\n", + " ax.set_xlim(x_min, x_max)\n", + " ax.set_ylim(y_min, y_max)\n", + " ax.set_zlim(z_min, z_max)\n", + " ax.set_xlabel(\"x\"); ax.set_ylabel(\"y\"); ax.set_zlabel(\"z (nm)\")\n", + "\n", + " def init():\n", + " _set_axes()\n", + " return []\n", + "\n", + " def update(i):\n", + " ax.cla()\n", + " c = frames[i]\n", + " # Clip beads to visible z range for plotting so outliers don't distort\n", + " visible = (c[:, 2] >= z_min) & (c[:, 2] <= z_max)\n", + " cc = np.vstack([c, c[0]])\n", + " ax.plot(cc[:, 0], cc[:, 1], cc[:, 2], \"-\", linewidth=1)\n", + " ax.scatter(c[visible, 0], c[visible, 1], c[visible, 2], s=5)\n", + " ax.plot_surface(X_plane, Y_plane, Z_plane, alpha=0.2, color=\"cyan\")\n", + " _set_axes()\n", + " ax.set_title(f\"Frame {i}/{len(frames)-1} | \"\n", + " f\"z ∈ [{c[:,2].min():.1f}, {c[:,2].max():.1f}] nm\")\n", + " return []\n", + "\n", + " ani = animation.FuncAnimation(\n", + " fig, update, frames=len(frames), init_func=init,\n", + " interval=int(interval_ms), blit=False\n", + " )\n", + " plt.close(fig)\n", + " display(HTML(ani.to_jshtml()))\n", + "\n", + "\n", + "# ── Run animation automatically (deterministic seed) ─────────────────────────\n", + "print(\"Generating initial ring and running MD (seed=0)…\")\n", + "anim_coords0 = make_tangled_ring_initial(seed=1)\n", + "anim_frames = run_md_relaxation(anim_coords0, seed=1,\n", + " n_frames=N_FRAMES,\n", + " steps_per_frame=STEPS_PER_FRAME)\n", + "print(f\"MD done — {len(anim_frames)} frames. Rendering animation…\")\n", + "show_md_animation(anim_frames)" + ] + }, + { + "cell_type": "markdown", + "id": "cell_md_05", + "metadata": { + "id": "cell_md_05" + }, + "source": [ + "# 6. Height based AFM Rendering\n", + "Once we have the coordinates of the relaxed chain either via Molecular Dynamics or without, we can start to convert the coordinates into a DNA chain as if it were imaged via AFM. We mimic tip convolution using a spherical tip to get the desired appearance. \n", + "\n", + "Here we define all the AFM rendering utilities. All functions described here are essential for getting the 'look' of the DNA chains. Function descriptions are added to the functions themselves. Information necessary to build the masks later on is also preserved in these functions." + ] + }, + { + "cell_type": "code", + "execution_count": 234, + "id": "cell_code_05", + "metadata": { + "id": "cell_code_05" + }, + "outputs": [], + "source": [ + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# Low-level geometry helpers\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "\n", + "def _seg_intersect_2d(\n", + " p1: np.ndarray,\n", + " p2: np.ndarray,\n", + " q1: np.ndarray,\n", + " q2: np.ndarray,\n", + " eps: float = 1e-12,\n", + ") -> tuple[bool, np.ndarray | None, float | None, float | None]:\n", + " \"\"\"Calculates the strict 2-D intersection of 2 line segments.\n", + "\n", + " This function is one of the functions used for the creation of the\n", + " chain from the bead coordinates.\n", + " The intersection point is defined by the parameters t and u such that:\n", + " point = p1 + t * (p2 - p1) = q1 + u * (q2 - q1)\n", + "\n", + " Parameters\n", + " ----------\n", + " p1, p2 : np.ndarray\n", + " Start and end points of the first line segment.\n", + " q1, q2 : np.ndarray\n", + " Start and end points of the second line segment.\n", + " eps : float, optional\n", + " A small positive value for numerical stability. Defaults to 1e-12.\n", + "\n", + " Returns\n", + " -------\n", + " is_intersecting : bool\n", + " True if the segments intersect, False otherwise.\n", + " intersection_point : np.ndarray or None\n", + " The [x, y] coordinates of the intersection point, or None if no\n", + " intersection exists.\n", + " parameter_t : float or None\n", + " The interpolation parameter along the first segment, or None.\n", + " parameter_u : float or None\n", + " The interpolation parameter along the second segment, or None.\n", + "\n", + " Examples\n", + " --------\n", + " >>> hit, pt, t, u = _seg_intersect_2d(p1, p2, q1, q2)\n", + " >>> print(hit, pt, t, u)\n", + " False None None None\n", + "\n", + " \"\"\"\n", + "\n", + " p1 = np.asarray(p1, dtype=float); p2 = np.asarray(p2, dtype=float)\n", + " q1 = np.asarray(q1, dtype=float); q2 = np.asarray(q2, dtype=float)\n", + " r = p2 - p1; s = q2 - q1\n", + " rxs = r[0]*s[1] - r[1]*s[0]\n", + " if abs(rxs) < eps:\n", + " return False, None, None, None\n", + " qp = q1 - p1\n", + " t = (qp[0]*s[1] - qp[1]*s[0]) / rxs\n", + " u = (qp[0]*r[1] - qp[1]*r[0]) / rxs\n", + " if 0.0 <= t <= 1.0 and 0.0 <= u <= 1.0:\n", + " return True, p1 + t*r, t, u\n", + " return False, None, None, None\n", + "\n", + "\n", + "def _circ_sep(\n", + " n: int,\n", + " i: int,\n", + " j: int,\n", + ") -> int:\n", + " \"\"\"Circular distance between bead indices on a ring of n beads.\n", + "\n", + " This helper function determines the minimal separation between two beads\n", + " along the perimeter of the ring, accounting for the periodic boundary.\n", + " It is used to distinguish between beads that form physical crossings\n", + " and those that are simply sequential neighbors. This function is used\n", + " downstream for crossing calculations\n", + "\n", + " Parameters\n", + " ----------\n", + " n : int\n", + " Number of beads in the ring.\n", + " i, j : int\n", + " Indices of the two beads for which to calculate the separation.\n", + "\n", + " Returns\n", + " -------\n", + " int\n", + " The minimal distance between the two beads.\n", + "\n", + " Examples\n", + " --------\n", + " >>> d = _circ_sep(n, i, j)\n", + " >>> d.type\n", + " int\n", + "\n", + " \"\"\"\n", + "\n", + " d = abs(int(i) - int(j))\n", + " return min(d, n - d)\n", + "\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# Structuring-element / grid helpers\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "\n", + "def disk_footprint(\n", + " r_px: float,\n", + ") -> np.ndarray:\n", + " \"\"\"Boolean circular footprint of radius r_px pixels.\n", + "\n", + " This function creates a 2D boolean mask representing a disk of a\n", + " specified radius. It is used to convert discrete bead coordinates into a\n", + " continuous chain structure by dilating each bead coordinate into a\n", + " disk-like structure. This is what builds the DNA chain radius.\n", + "\n", + " Parameters\n", + " ----------\n", + " r_px : float\n", + " Radius of the disk in pixels.\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray\n", + " A boolean array with True values inside the disk and false outside.\n", + "\n", + " Examples\n", + " --------\n", + " >>> footprint = disk_footprint(r_px)\n", + " >>> print(footprint.shape, footprint.dtype)\n", + " (5, 5) bool\n", + "\n", + " \"\"\"\n", + "\n", + " if r_px < 0.5:\n", + " return np.ones((1, 1), dtype=bool)\n", + " r = int(np.ceil(r_px))\n", + " y, x = np.ogrid[-r:r+1, -r:r+1]\n", + " return (x*x + y*y) <= r*r\n", + "\n", + "\n", + "def upsample_nn(\n", + " a: np.ndarray,\n", + " out_shape: tuple[int, int],\n", + ") -> np.ndarray:\n", + " \"\"\"Nearest-neighbour upsample array a to out_shape.\n", + "\n", + " This function increases the resolution of an input array (such as an AFM\n", + " height map or a boolean mask) by repeating elements. If the target\n", + " dimensions are not exact multiples of the input dimensions, the resulting\n", + " array is clipped to the specified target shape.\n", + "\n", + " Parameters\n", + " ----------\n", + " a : np.ndarray\n", + " Input array to be upsampled.\n", + " out_shape : tuple\n", + " Target shape of the upsampled array.\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray\n", + " Upsampled array of shape out_shape\n", + "\n", + " Examples\n", + " --------\n", + " >>> upsampled_array = upsample_nn(input_array, target_shape)\n", + " >>> print(upsampled_array.shape)\n", + " (target_shape[0], target_shape[1])\n", + "\n", + " \"\"\"\n", + "\n", + " ny_out, nx_out = out_shape\n", + " ny_in, nx_in = a.shape\n", + " if (ny_out, nx_out) == (ny_in, nx_in):\n", + " return a\n", + " sy = max(ny_out // ny_in, 1)\n", + " sx = max(nx_out // nx_in, 1)\n", + " a_up = a.repeat(sy, axis=0).repeat(sx, axis=1)\n", + " return a_up[:ny_out, :nx_out]\n", + "\n", + "\n", + "#internal render grid comes directly from extent and user nm_per_px\n", + "\n", + "def compute_internal_render_grid(\n", + " extent: tuple[float, float, float, float],\n", + " target_nm_per_px: float,\n", + " min_size: int = 16,\n", + ") -> tuple[int, int, float]:\n", + " \"\"\"Build the internal render grid from physical extent and user nm_per_px.\n", + "\n", + " This function determines the size of the grid for the resolution that the\n", + " user desires. It is based on values chosen for target_nm_per_px and\n", + " nm_per_pix. It also handles potential zero-division or negative resolution\n", + " values.\n", + "\n", + " Parameters\n", + " ----------\n", + " extent : tuple\n", + " boundaries of the simulation space\n", + " target_nm_per_px : float\n", + " desired resolution multiplied by a scaling factor in nm/pixel\n", + " min_size : int, optional\n", + " minimum size of the grid in pixels. Default 16\n", + "\n", + " Returns\n", + " -------\n", + " tuple\n", + " size of the grid\n", + "\n", + " Examples\n", + " --------\n", + " >>> nx, ny, p_nm_per_px = compute_internal_render_grid(extent,\n", + " target_nm_per_px)\n", + " >>> print(nx, ny, p_nm_per_px)\n", + " 256 256 0.5\n", + "\n", + " \"\"\"\n", + "\n", + " xmin, xmax, ymin, ymax = extent\n", + " width_nm = float(xmax - xmin)\n", + " height_nm = float(ymax - ymin)\n", + " p_nm_per_px = max(float(target_nm_per_px), 1e-6)\n", + " nx = max(int(min_size), int(np.ceil(width_nm / p_nm_per_px)) + 1)\n", + " ny = max(int(min_size), int(np.ceil(height_nm / p_nm_per_px)) + 1)\n", + " return nx, ny, p_nm_per_px\n", + "\n", + "\n", + "def resize_image_to_shape(\n", + " a: np.ndarray,\n", + " out_shape: tuple[int, int],\n", + " order: int =1,\n", + ") -> np.ndarray:\n", + " \"\"\"Resize 2D array a to out_shape using scipy.ndimage.zoom.\n", + "\n", + " This function utilizes `scipy.ndimage.zoom` to scale the input array. It\n", + " includes safety checks for edge-case padding and cropping to ensure the\n", + " output array matches the requested dimensions exactly.\n", + "\n", + " Parameters\n", + " ----------\n", + " a : np.ndarray\n", + " Input array to be resized.\n", + " out_shape : tuple\n", + " Target shape of the resized\n", + " order : int, optional\n", + " Order of the interpolation. Defaults to 1.\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray\n", + " Resized array of shape out_shape\n", + "\n", + " Examples\n", + " --------\n", + " >>> resized_array = resize_image_to_shape(input_array, target_shape)\n", + " >>> print(resized_array.shape)\n", + " (target_shape[0], target_shape[1])\n", + "\n", + " \"\"\"\n", + "\n", + " a = np.asarray(a)\n", + " out_shape = tuple(int(v) for v in out_shape)\n", + " if a.shape == out_shape:\n", + " return a.copy()\n", + " zoom_factors = (out_shape[0] / a.shape[0], out_shape[1] / a.shape[1])\n", + " out = zoom(a, zoom_factors, order=order, mode=\"nearest\",\n", + " prefilter=(order > 1))\n", + " out = out[:out_shape[0], :out_shape[1]]\n", + " if out.shape != out_shape:\n", + " pad_y = max(0, out_shape[0] - out.shape[0])\n", + " pad_x = max(0, out_shape[1] - out.shape[1])\n", + " out = np.pad(out, ((0, pad_y), (0, pad_x)), mode=\"edge\")\n", + " out = out[:out_shape[0], :out_shape[1]]\n", + " return out\n", + "\n", + "\n", + "def dna_shape(\n", + " radius_nm: float,\n", + " p_nm_per_px: float,\n", + " max_radius_px: int = 96,\n", + ")-> np.ndarray:\n", + " \"\"\"Hemispherical structuring element representing the DNA cross-section.\n", + "\n", + " This function generates a 2D height map representing the physical profile\n", + " of a DNA strand. Each pixel within the radius of the DNA is assigned a\n", + " height value based on the spherical-cap formula, representing the vertical\n", + " profile encountered during an AFM scan.\n", + "\n", + " Parameters\n", + " ----------\n", + " radius_nm : float\n", + " Radius of the disk in nanometers.\n", + " p_nm_per_px : float\n", + " Physical pixel size in nanometers.\n", + " max_radius_px : int, optional\n", + " Maximum radius in pixels. Defaults to 96.\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray\n", + " Height map of shape (2*R+1, 2*R+1)\n", + "\n", + " Example\n", + " -------\n", + " >>> height_map = dna_shape(radius_nm, p_nm_per_px)\n", + " >>> print(height_map.shape, height_map.dtype)\n", + " (5, 5) float32\n", + "\n", + " \"\"\"\n", + "\n", + " r_px = radius_nm / max(p_nm_per_px, 1e-12)\n", + " R = int(np.clip(np.ceil(r_px), 1, max_radius_px))\n", + " y, x = np.ogrid[-R:R+1, -R:R+1]\n", + " d2 = x*x + y*y\n", + " inside = d2 <= (r_px * r_px)\n", + " d_nm = np.sqrt(d2).astype(np.float32) * np.float32(p_nm_per_px)\n", + " structure = np.full((2*R+1, 2*R+1), -1e9, dtype=np.float32)\n", + " structure[inside] = np.sqrt(\n", + " np.maximum(radius_nm**2 - d_nm[inside]**2, 0.0)\n", + " ).astype(np.float32)\n", + " return inside.astype(bool), structure\n", + "\n", + "\n", + "def AFM_tip(\n", + " tip_radius_nm: float,\n", + " p_nm_per_px: float,\n", + " max_radius_px: int = 128,\n", + ") -> tuple[np.ndarray, np.ndarray]:\n", + " \"\"\"Spherical-cap structuring element representing the AFM tip geometry.\n", + "\n", + "\n", + " This function calculates the relative vertical profile of a spherical AFM\n", + " tip. The resulting height map is used to perform a morphological dilation\n", + " on the sample surface, simulating the physical interaction (convolution)\n", + " between the tip and the sample. The height is normalized so that the\n", + " tip apex is at 0.0.\n", + "\n", + " Parameters\n", + " ----------\n", + " tip_radius_nanometers : float\n", + " The physical radius of the AFM tip in nanometers.\n", + " nanometers_per_pixel : float\n", + " The spatial resolution of the simulation grid in nanometers per pixel.\n", + " maximum_radius_pixels : int, optional\n", + " A safety limit for the pixel radius of the structuring element to\n", + " prevent excessive memory consumption. Defaults to 128.\n", + "\n", + " Returns\n", + " -------\n", + " occupancy_mask : np.ndarray\n", + " A 2D boolean array representing the circular footprint of the tip.\n", + " height_structure_element : np.ndarray\n", + " A 2D float32 array containing the vertical profile offsets of the\n", + " spherical cap. Pixels outside the tip footprint are assigned a\n", + " large negative value (-1e9).\n", + "\n", + " Example\n", + " -------\n", + " >>> occupancy_mask, height_structure_element = AFM_tip(tip_radius_nm,\n", + " p_nm_per_px)\n", + " >>> print(occupancy_mask.shape, occupancy_mask.dtype)\n", + " (5, 5) bool\n", + "\n", + " \"\"\"\n", + "\n", + " Rpx = tip_radius_nm / max(p_nm_per_px, 1e-12)\n", + " R = int(np.clip(np.ceil(Rpx), 1, max_radius_px))\n", + " y, x = np.ogrid[-R:R+1, -R:R+1]\n", + " d2 = x*x + y*y\n", + " inside = d2 <= (Rpx * Rpx)\n", + " d_nm = np.sqrt(d2).astype(np.float32) * np.float32(p_nm_per_px)\n", + " structure = np.full((2*R+1, 2*R+1), -1e9, dtype=np.float32)\n", + " structure[inside] = (\n", + " np.sqrt(np.maximum(tip_radius_nm**2 - d_nm[inside]**2, 0.0))\n", + " - tip_radius_nm\n", + " ).astype(np.float32)\n", + " return inside.astype(bool), structure\n", + "\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# Crossing boost\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "\n", + "def calculate_crossing_taper_weight(\n", + " idx_off: int,\n", + " w: int,\n", + " profile: str = \"gaussian\",\n", + " sigma: float | None = None,\n", + ") -> float:\n", + " \"\"\"Smooth weight in [0, 1] used to fade the crossing height boost.\n", + "\n", + " This function generates a weighting factor between 0 and 1 used to\n", + " gradually decrease the height offset applied to DNA segments near a\n", + " detected crossing. It ensures that the transition between the boosted\n", + " crossing region and the standard polymer chain is smooth.\n", + " There are 3 types of profiles possible to be applied\n", + " for smoothing a crossing, guassian, hemisphere, and linear.\n", + "\n", + " Parameters\n", + " ----------\n", + " idx_off : int\n", + " The distance in bead indices from the center of the crossing.\n", + " w : int\n", + " The number of beads on either side of the center over which the weight\n", + " should taper to zero.\n", + " profile : str, optional\n", + " The mathematical shape of the taper. Options are:\n", + " - 'gaussian': A smooth bell-shaped decay (recommended).\n", + " - 'hemisphere': A circular arc taper.\n", + " - 'linear': A simple linear ramp.\n", + " Defaults to 'gaussian'.\n", + " sigma : float, optional\n", + " The standard deviation for the Gaussian profile. If None, it is\n", + " automatically determined based on the window width.\n", + "\n", + " Returns\n", + " -------\n", + " float\n", + " A weighting factor in the range [0.0, 1.0].\n", + "\n", + " Examples\n", + " --------\n", + " >>> wt = calculate_crossing_taper_weight(idx_off, w)\n", + " >>> print(wt.dtype)\n", + " float32\n", + "\n", + " \"\"\"\n", + "\n", + " if w <= 0:\n", + " return 1.0\n", + " a = abs(idx_off)\n", + " if profile == \"linear\":\n", + " return 1.0 - (a / (w + 1.0))\n", + " if profile == \"hemisphere\":\n", + " x = a / (w + 1.0)\n", + " return float(np.sqrt(max(0.0, 1.0 - x*x)))\n", + " # gaussian (default)\n", + " if sigma is None:\n", + " sigma = max(1e-6, 0.5 * (w + 0.5))\n", + " g = float(np.exp(-(idx_off**2) / (2.0 * sigma**2)))\n", + " g_end = float(np.exp(-(w**2) / (2.0 * sigma**2)))\n", + " if g_end < 0.999:\n", + " g = float(np.clip((g - g_end) / (1.0 - g_end), 0.0, 1.0))\n", + " return g\n", + "\n", + "\n", + "def collect_intersections(\n", + " xy_nm: np.ndarray,\n", + " min_separation_beads: int = 12,\n", + " merge_radius_nm: float = 0.5,\n", + ")-> list[dict]:\n", + " \"\"\"Identify all self-intersections in a closed ring polyline.\n", + "\n", + " This function performs a brute-force search across all segment pairs of\n", + " the polyline to find crossings. It ignores adjacent segments, shared\n", + " vertices, and segments that are close to each other along the contour of\n", + " the ring. Detected intersections are subsequently clustered to handle\n", + " multi-segment vertex hits.\n", + "\n", + " Parameters\n", + " ----------\n", + "\n", + " xy_nm : np.ndarray\n", + " Array of shape (n, 2)\n", + " min_separation_beads : int, optional\n", + " Minimum separation between segments in beads. Defaults to 12.\n", + " merge_radius_nm : float, optional\n", + " Maximum separation between segments in nanometers. Defaults to 0.5.\n", + "\n", + " Returns\n", + " -------\n", + " list of dicts:\n", + " {pt_nm, seg_i, seg_j, t, u, n_hits}\n", + " list[dict]\n", + " A list of dictionaries, where each dictionary represents a unique\n", + " crossing and contains:\n", + " - \"pt_nm\": The [x, y] coordinates of the intersection.\n", + " - \"seg_i\": The index of the first segment involved.\n", + " - \"seg_j\": The index of the second segment involved.\n", + " - \"t\": Interpolation parameter along segment A.\n", + " - \"u\": Interpolation parameter along segment B.\n", + " - \"n_hits\": The number of raw intersections merged into this cluster.\n", + "\n", + " Examples\n", + " --------\n", + " >>> clusters = collect_intersections(xy_nm,\n", + " min_separation_beads=int(min_separation_beads),\n", + " merge_radius_nm=float(merge_radius_nm)\n", + " >>> print(clusters.type)\n", + " list[dicts]\n", + "\n", + " \"\"\"\n", + "\n", + " xy = np.asarray(xy_nm, dtype=float)\n", + " n = int(xy.shape[0])\n", + " raw = []\n", + " for i in range(n):\n", + " i2 = (i + 1) % n\n", + " p1, p2 = xy[i], xy[i2]\n", + " for j in range(i + 1, n):\n", + " j2 = (j + 1) % n\n", + " if i == j or i2 == j or j2 == i:\n", + " continue\n", + " if _circ_sep(n, i, j) < int(min_separation_beads):\n", + " continue\n", + " q1, q2 = xy[j], xy[j2]\n", + " hit, pt, t, u = _seg_intersect_2d(p1, p2, q1, q2)\n", + " if hit:\n", + " raw.append(dict(pt=np.array(pt, float),\n", + " seg_i=int(i), seg_j=int(j),\n", + " t=float(t), u=float(u)))\n", + "\n", + " clusters = merge_crossing_clusters(raw, merge_radius_nm=merge_radius_nm)\n", + " return clusters\n", + "\n", + "\n", + "def merge_crossing_clusters(\n", + " raw_list: list[dict],\n", + " merge_radius_nm: float = 0.5,\n", + ") -> list[dict]:\n", + " \"\"\"Group nearby raw intersection points into single averaged clusters.\n", + "\n", + " This function uses a greedy proximity-based algorithm to cluster\n", + " intersections that occur close to each other (e.g., where multiple\n", + " segments meet at a single vertex). It calculates the centroid for each\n", + " cluster and retains metadata from the first intersection encountered in\n", + " each group.\n", + "\n", + " Parameters\n", + " ----------\n", + " raw_list : list[dict]\n", + " A list of dictionaries containing raw intersection data. Each\n", + " dictionary must include the key \"point\" (a 2D numpy array).\n", + " merge_radius_nm : float, optional\n", + " The maximum Euclidean distance allowed between an intersection point\n", + " and a cluster's current centroid for it to be merged. Defaults to 0.5.\n", + "\n", + " Returns\n", + " -------\n", + " list[dict]\n", + "\n", + " Examples\n", + " --------\n", + " >>> clusters = merge_crossing_clusters(raw_list,\n", + " merge_radius_nm=float(merge_radius_nm))\n", + " >>> print(clusters.type)\n", + " list[dict]\n", + "\n", + " \"\"\"\n", + "\n", + " clusters = []\n", + " for r in raw_list:\n", + " pt = r[\"pt\"].astype(float)\n", + " placed = False\n", + " for c in clusters:\n", + " if np.linalg.norm(pt -\n", + " c[\"pt_sum\"] / c[\"n\"]) <= float(merge_radius_nm):\n", + " c[\"pt_sum\"] += pt\n", + " c[\"n\"] += 1\n", + " c[\"items\"].append(r)\n", + " placed = True\n", + " break\n", + " if not placed:\n", + " clusters.append({\"pt_sum\": pt.copy(), \"n\": 1, \"items\": [r]})\n", + "\n", + " out = []\n", + " for c in clusters:\n", + " pt = (c[\"pt_sum\"] / c[\"n\"]).astype(np.float32)\n", + " rep = c[\"items\"][0]\n", + " out.append(dict(\n", + " pt_nm = pt,\n", + " seg_i = int(rep[\"seg_i\"]),\n", + " seg_j = int(rep[\"seg_j\"]),\n", + " t = float(rep[\"t\"]),\n", + " u = float(rep[\"u\"]),\n", + " n_hits = int(c[\"n\"]),\n", + " ))\n", + " return out\n", + "\n", + "\n", + "def boost_crossings_intersections(\n", + " x_nm: np.ndarray,\n", + " y_nm: np.ndarray,\n", + " zc_nm: np.ndarray,\n", + " crossings: list[dict] | None = None,\n", + " min_separation_beads: int = 12,\n", + " boost_window_beads: int = 2,\n", + " guaranteed_offset_nm: float = 1.0,\n", + " boost_method: str = \"additive\",\n", + " boost_profile: str = \"gaussian\",\n", + " boost_sigma_beads: float | None = None,\n", + " far_clip_nm: float | None =2.5,\n", + " far_clip_window_beads: int = 12,\n", + " merge_radius_nm: float = 0.5,\n", + ") -> tuple[np.ndarray, list[dict]]:\n", + " \"\"\"Boost z-height at strand crossings so they are visually distinct.\n", + "\n", + " This function identifies self-intersections in a 2D projection and\n", + " physically separates the strands in 3D. For each crossing, it determines\n", + " which segment is 'on top' and raises its vertical profile using a tapered\n", + " window to ensure a realistic and visually distinct crossover point.\n", + " For each crossing it:\n", + " - Determines which strand is on top (higher z)\n", + " - Raises top-strand beads in a tapered window to at least\n", + " (bottom_max + guaranteed_offset_nm)\n", + " - Optionally clips non-crossing beads to far_clip_nm\n", + "\n", + " Parameters\n", + " ----------\n", + " x_nm : np.ndarray\n", + " The x-coordinates of the polymer chain.\n", + " y_nm : np.ndarray\n", + " The y-coordinates of the polymer chain.\n", + " zc_nm : np.ndarray\n", + " The initial z-coordinates of the polymer chain.\n", + " crossings : list[dict]\n", + " Pre-computed crossing data. If None, crossings are detected\n", + " automatically using `collect_polyline_intersections`.\n", + " min_separation_beads : int, optional\n", + " Minimum separation between segments in beads. Defaults to 12.\n", + " boost_window_beads : int, optional\n", + " The number of beads to boost. Defaults to 2.\n", + " guaranteed_offset_nm : float, optional\n", + " The minimum boost height in nanometers. Defaults to 1.0.\n", + " boost_method : str\n", + " The logic for height calculation\n", + " boost_profile : str\n", + " The shape of the tapering profile\n", + " boost_sigma_beads : float\n", + " The standard deviation for gaussian tapering\n", + " far_clip_nm : float\n", + " If applied caps the height of beads far from any crossing to this value.\n", + " far_clip_window_beads : int\n", + " The number of beads to clip.\n", + " merge_radius_nm : float\n", + " The maximum Euclidean distance for nearby raw intersections.\n", + "\n", + " Returns\n", + " -------\n", + " z : np.ndarray\n", + " The updated z-coordinates with crossings boosted.\n", + " crossing_info : list[dict]\n", + " Information regarding the identified and modified crossings.\n", + "\n", + " Examples\n", + " --------\n", + " >>> z, crossing_info = boost_crossings_intersections(x, y, z)\n", + " >>> print(z.shape, type(crossing_info))\n", + " (N,3) \n", + "\n", + " \"\"\"\n", + "\n", + " x = np.asarray(x_nm, dtype=np.float32)\n", + " y = np.asarray(y_nm, dtype=np.float32)\n", + " z = np.asarray(zc_nm, dtype=np.float32).copy()\n", + " n = int(z.shape[0])\n", + " if n < 5:\n", + " return z.astype(np.float32), []\n", + "\n", + " if crossings is None:\n", + " xy = np.stack([x, y], axis=1)\n", + " crossings = collect_intersections(\n", + " xy,\n", + " min_separation_beads=int(min_separation_beads),\n", + " merge_radius_nm=float(merge_radius_nm),\n", + " )\n", + "\n", + " def get_segment_indices(\n", + " center: int,\n", + " w: int,\n", + " ) -> np.ndarray:\n", + " \"\"\"\n", + " Calculate indices in a window around a center bead,\n", + " handling periodicity.\n", + "\n", + " Parameters\n", + " ----------\n", + " center : int\n", + " The index of the center bead.\n", + " w : int\n", + " The number of beads on either side of the center\n", + " to include.\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray\n", + "\n", + " \"\"\"\n", + "\n", + " return np.array([(center + k) % n for k in range(-w, w+1)],\n", + " dtype=np.int32)\n", + "\n", + " crossing_info = []\n", + " crossing_centers = []\n", + " w = int(boost_window_beads)\n", + "\n", + " for c in crossings:\n", + " i = int(c[\"seg_i\"]); j = int(c[\"seg_j\"])\n", + " i2 = (i + 1) % n; j2 = (j + 1) % n\n", + " ti = float(c.get(\"t\", 0.5)); uj = float(c.get(\"u\", 0.5))\n", + "\n", + " bead_i = i if ti < 0.5 else i2\n", + " bead_j = j if uj < 0.5 else j2\n", + " zi = float((1.0 - ti) * z[i] + ti * z[i2])\n", + " zj = float((1.0 - uj) * z[j] + uj * z[j2])\n", + "\n", + " top_center, bottom_center = (bead_i, bead_j) if zi >= zj else (bead_j,\n", + " bead_i)\n", + " top_seg = get_segment_indices(top_center, w)\n", + " bottom_seg = get_segment_indices(bottom_center, w)\n", + "\n", + " bl_max = float(z[bottom_seg].max())\n", + " tl_max = float(z[top_seg].max())\n", + "\n", + " if boost_method == \"absolute\":\n", + " target_height = bl_max + float(guaranteed_offset_nm)\n", + " else:\n", + " target_height = max(tl_max, bl_max) + float(guaranteed_offset_nm)\n", + "\n", + " for off in range(-w, w+1):\n", + " k = (top_center + off) % n\n", + " wt = float(calculate_crossing_taper_weight(off, w,\n", + " profile=boost_profile,\n", + " sigma=boost_sigma_beads))\n", + " z[k] = float((1.0 - wt) * z[k] + wt * max(z[k], target_height))\n", + "\n", + " crossing_centers.extend([int(top_center), int(bottom_center)])\n", + " crossing_info.append(dict(\n", + " pt_nm = np.asarray(c[\"pt_nm\"], dtype=np.float32),\n", + " seg_i = int(i),\n", + " seg_j = int(j),\n", + " top_center = int(top_center),\n", + " bottom_center= int(bottom_center),\n", + " ))\n", + "\n", + " # Clip beads far from any crossing\n", + " if crossing_centers and far_clip_nm is not None:\n", + " centers = np.array(crossing_centers, dtype=np.int32)\n", + " r = int(far_clip_window_beads)\n", + " for k in range(n):\n", + " d = int(np.min(np.minimum(np.abs(k - centers),\n", + " n - np.abs(k - centers))))\n", + " if d > r:\n", + " z[k] = min(z[k], float(far_clip_nm))\n", + "\n", + " return z.astype(np.float32), crossing_info\n", + "\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# Main AFM renderer\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "\n", + "def create_z_based_afm(\n", + " coords: np.ndarray,\n", + " nx: int = 800,\n", + " ny: int = 800,\n", + " dna_diameter_nm: float = 2.0,\n", + " tip_radius_nm: float = 0.01,\n", + " max_height_nm: float = 6.0,\n", + " target_nm_per_px: float = 0.08,\n", + " max_radius_px: int = 96,\n", + " radius_shrink_px: float = 2.0,\n", + " final_blur_sigma_px: float = 0.20,\n", + " apply_edge_taper: bool = True,\n", + " taper_sigma_nm: float = 0.45,\n", + " taper_floor: float = 0.10,\n", + " add_center_ridge: bool = True,\n", + " ridge_sigma_nm: float = 0.25,\n", + " ridge_amp_nm: float = 0.25,\n", + " grain_nm: float = 0.0,\n", + " grain_sigma_px: float = 0.6,\n", + " grain_seed: int = 1,\n", + " enable_crossing_boost: bool = True,\n", + " min_separation_beads: int = 12,\n", + " boost_window_beads: int = 2,\n", + " guaranteed_offset_nm: float = 1.0,\n", + " boost_method: str = \"additive\",\n", + " boost_profile: str = \"gaussian\",\n", + " boost_sigma_beads: float | None = None,\n", + " crossings_precomputed: list[dict] | None = None,\n", + " far_clip_nm: float | None = 2.5,\n", + " far_clip_window_beads: int = 12,\n", + " return_crossing_info: bool = False,\n", + " return_masks: bool = True,\n", + " extent: tuple[float, float, float, float] | None = None,\n", + ") -> tuple[np.ndarray, dict | tuple]:\n", + " \"\"\"Master AFM renderer for simulating images from 3D coordinates.\n", + "\n", + " This pipeline projects 3D bead coordinates onto a 2D grid, manages\n", + " crossings, rasterizes the polymer backbone, applies morphological\n", + " dilations for DNA shape and AFM tip convolution, and adds realistic optical\n", + " and physical artifacts (taper, ridge, noise).\n", + " It follows the following steps:\n", + " 1. Project 3-D bead coords onto a 2-D effective grid\n", + " 2. Rasterise closed polyline with z-interpolation\n", + " 3. Optionally boost crossing heights (boost_crossings_intersections)\n", + " 4. Apply dna_shape (DNA cylindrical cross-section)\n", + " 5. Apply AFM_tip (tip-sample convolution)\n", + " 6. Clip, blur, edge-taper, center-ridge\n", + " 7. Optional synthetic grain noise\n", + " 8. Upsample to requested (nx, ny)\n", + "\n", + " Parameters\n", + " ----------\n", + " coords : np.ndarray\n", + " Array of shape (n, 3) containing x, y, z coordinates.\n", + " nx : int\n", + " Number of pixels in the x-direction.\n", + " ny : int\n", + " Number of pixels in the y-direction.\n", + " dna_diameter_nm : float\n", + " DNA diameter in nanometers.\n", + " tip_radius_nm : float\n", + " Tip radius in nanometers.\n", + " max_height_nm : float\n", + " Maximum height in nanometers.\n", + " target_nm_per_px : float\n", + " Target number of nanometers per pixel.\n", + " max_radius_px : int\n", + " Maximum radius in pixels.\n", + " radius_shrink_px : float\n", + " Radius shrinking factor.\n", + " final_blur_sigma_px : float\n", + " Final blur sigma in pixels.\n", + " apply_edge_taper : bool\n", + " Apply edge taper.\n", + " taper_sigma_nm : float\n", + " Taper sigma in nanometers.\n", + " taper_floor : float\n", + " Taper floor.\n", + " add_center_ridge : bool\n", + " Add center ridge.\n", + " ridge_sigma_nm : float\n", + " Ridge sigma in nanometers.\n", + " ridge_amp_nm : float\n", + " Ridge amplitude in nanometers.\n", + " grain_nm : float\n", + " Grain size in nanometers.\n", + " grain_sigma_px : float\n", + " Grain sigma in pixels.\n", + " grain_seed : int\n", + " Grain seed.\n", + " enable_crossing_boost : bool\n", + " Enable crossing boost.\n", + " min_separation_beads : int\n", + " Minimum separation between segments in beads.\n", + " boost_window_beads : int\n", + " The number of beads to boost.\n", + " guaranteed_offset_nm : float\n", + " The minimum boost height in nanometers.\n", + " boost_method : str\n", + " The logic for height calculation\n", + " boost_profile : str\n", + " The shape of the tapering profile\n", + " boost_sigma_beads : float\n", + " The standard deviation for gaussian tapering\n", + " crossings_precomputed : list[dict]\n", + " Pre-computed crossing data.\n", + " far_clip_nm : float\n", + " If applied caps the height of beads\n", + " far from any crossing to this value.\n", + " far_clip_window_beads : int\n", + " The number of beads to clip.\n", + " return_crossing_info : bool\n", + " Return crossing info.\n", + " return_masks : bool\n", + " Return masks.\n", + " extent : tuple[float, float, float, float]\n", + " Extent of the output image.\n", + "\n", + " Returns\n", + " -------\n", + " afm_image : np.ndarray\n", + " The simulated 2D AFM height map.\n", + " debug_dict : dict or tuple\n", + " A dictionary containing masks and metadata (if return_masks=True),\n", + " or a tuple containing the physical (xmin, xmax, ymin, ymax) extent.\n", + "\n", + " Examples\n", + " --------\n", + " >>> afm_image, debug_dict = create_z_based_afm(coords, nx=800, ny=800,\n", + " return_masks=True)\n", + " >>> print(afm_image.shape, type(debug_dict))\n", + " (800, 800) \n", + "\n", + " \"\"\"\n", + "\n", + " x, y, z = coords.T\n", + " if extent is None:\n", + " xmin, xmax = float(x.min() - 2), float(x.max() + 2)\n", + " ymin, ymax = float(y.min() - 2), float(y.max() + 2)\n", + " else:\n", + " xmin, xmax, ymin, ymax = extent\n", + "\n", + " nx_eff, ny_eff = int(nx), int(ny)\n", + " px_eff = (xmax - xmin) / max(nx_eff - 1, 1)\n", + " py_eff = (ymax - ymin) / max(ny_eff - 1, 1)\n", + " p_eff = 0.5 * (px_eff + py_eff)\n", + "\n", + " ix = np.clip(((x - xmin) / (xmax - xmin) * (nx_eff - 1)).astype(np.int32),\n", + " 0, nx_eff - 1)\n", + " iy = np.clip(((y - ymin) / (ymax - ymin) * (ny_eff - 1)).astype(np.int32),\n", + " 0, ny_eff - 1)\n", + "\n", + " zc = (z - z.min()).astype(np.float32)\n", + "\n", + " # ── Crossing boost ───────────────────────────────────────────────────────\n", + " crossing_info = []\n", + " if enable_crossing_boost:\n", + " zc, crossing_info = boost_crossings_intersections(\n", + " x.astype(np.float32), y.astype(np.float32), zc,\n", + " crossings=crossings_precomputed,\n", + " min_separation_beads=int(min_separation_beads),\n", + " boost_window_beads=int(boost_window_beads),\n", + " guaranteed_offset_nm=float(guaranteed_offset_nm),\n", + " boost_method=str(boost_method),\n", + " boost_profile=str(boost_profile),\n", + " boost_sigma_beads=boost_sigma_beads,\n", + " far_clip_nm=far_clip_nm,\n", + " far_clip_window_beads=int(far_clip_window_beads),\n", + " )\n", + "\n", + " # ── Rasterise polyline ───────────────────────────────────────────────────\n", + " z_line = np.zeros((ny_eff, nx_eff), dtype=np.float32)\n", + " line_mask = np.zeros((ny_eff, nx_eff), dtype=bool)\n", + " npts = len(ix)\n", + " for k in range(npts):\n", + " k2 = (k + 1) % npts\n", + " x0, y0, z0 = int(ix[k]), int(iy[k]), float(zc[k])\n", + " x1, y1, z1 = int(ix[k2]), int(iy[k2]), float(zc[k2])\n", + " n_seg = int(max(abs(x1 - x0), abs(y1 - y0)) + 1)\n", + " if n_seg <= 1:\n", + " z_line[y0, x0] = max(z_line[y0, x0], z0)\n", + " line_mask[y0, x0] = True\n", + " continue\n", + " xs = np.linspace(x0, x1, n_seg).astype(np.int32)\n", + " ys = np.linspace(y0, y1, n_seg).astype(np.int32)\n", + " zs = np.linspace(z0, z1, n_seg).astype(np.float32)\n", + " if xs.size > 1:\n", + " keep = np.ones(xs.shape[0], dtype=bool)\n", + " keep[1:] = (xs[1:] != xs[:-1]) | (ys[1:] != ys[:-1])\n", + " xs, ys, zs = xs[keep], ys[keep], zs[keep]\n", + " z_line[ys, xs] = np.maximum(z_line[ys, xs], zs)\n", + " line_mask[ys, xs] = True\n", + "\n", + " # ── DNA cap dilation ─────────────────────────────────────────────────────\n", + "\n", + " r_eff = max(0.5 * float(dna_diameter_nm), 0.2)\n", + " fp_dna, cap = dna_shape(r_eff, p_eff, max_radius_px=max_radius_px)\n", + " surface = grey_dilation(z_line, footprint=fp_dna,\n", + " structure=cap).astype(np.float32)\n", + " dna_region = grey_dilation(line_mask.astype(np.uint8), footprint=fp_dna)>0\n", + " surface[~dna_region] = 0.0\n", + "\n", + " # ── Tip convolution ──────────────────────────────────────────────────────\n", + " r_tip_px = float(tip_radius_nm) / max(p_eff, 1e-12)\n", + " if r_tip_px >= 0.5:\n", + " fp_tip, tip_struct = AFM_tip(\n", + " float(tip_radius_nm), p_eff, max_radius_px=max_radius_px)\n", + " surface = grey_dilation(surface, footprint=fp_tip,\n", + " structure=tip_struct).astype(np.float32)\n", + "\n", + " np.clip(surface, 0, max_height_nm, out=surface)\n", + " if final_blur_sigma_px > 0:\n", + " fbsp=float(final_blur_sigma_px)\n", + " surface = gaussian_filter(surface,\n", + " sigma=fbsp).astype(np.float32)\n", + "\n", + " # ── Edge taper + center ridge ────────────────────────────────────────────\n", + " if (apply_edge_taper or add_center_ridge) and np.any(line_mask):\n", + " dist_px = distance_transform_edt(~line_mask).astype(np.float32)\n", + " dist_nm = dist_px * np.float32(p_eff)\n", + " if apply_edge_taper:\n", + " sig = max(float(taper_sigma_nm), 1e-6)\n", + " factor = taper_floor + (1.0 - taper_floor) * np.exp(\n", + " -(dist_nm**2) / (2.0 * sig**2))\n", + " surface[dna_region] *= factor[dna_region]\n", + " if add_center_ridge and ridge_amp_nm > 0:\n", + " rs = max(float(ridge_sigma_nm), 1e-6)\n", + " ridge = np.exp(-(dist_nm**2) / (2.0 * rs**2))\n", + " surface[dna_region] += ridge_amp_nm * ridge[dna_region]\n", + " np.clip(surface, 0, max_height_nm, out=surface)\n", + "\n", + " # ── Synthetic grain ──────────────────────────────────────────────────────\n", + " if grain_nm and grain_nm > 0:\n", + " rng = np.random.default_rng(int(grain_seed))\n", + " n = rng.normal(0.0, 1.0, size=surface.shape).astype(np.float32)\n", + " if grain_sigma_px and grain_sigma_px > 0:\n", + " n = gaussian_filter(n,\n", + " sigma=float(grain_sigma_px)).astype(np.float32)\n", + " v=n[dna_region].std()\n", + " std = float(v) if np.any(dna_region) else float(n.std())\n", + " if std > 1e-9:\n", + " n /= np.float32(std)\n", + " surface[dna_region] *= (1.0 + np.float32(grain_nm) * n[dna_region])\n", + " np.clip(surface, 0, max_height_nm, out=surface)\n", + "\n", + " if return_masks:\n", + " debug = {\n", + " \"line_mask\": line_mask,\n", + " \"dna_region\": dna_region,\n", + " \"extent\": (xmin, xmax, ymin, ymax),\n", + " \"p_nm_per_px\": float(p_eff),\n", + " }\n", + " if return_crossing_info:\n", + " debug[\"crossings\"] = crossing_info\n", + " return surface, debug\n", + "\n", + " return surface, (xmin, xmax, ymin, ymax)" + ] + }, + { + "cell_type": "markdown", + "id": "cell_md_06", + "metadata": { + "id": "cell_md_06" + }, + "source": [ + "# 7. Noise Functions\n", + "Here we describe all the functions and utilities needed to extract and add the noise to our generated AFM_img. Depending on the choice of the user either:\n", + "\n", + "1. Bruker/Nanoscope `.spm` file parser and TopoStats-like noise extraction pipeline is used or,\n", + "2. If no blank `.spm` file is supplied, the notebook falls back to a PSD-based synthetic noise model.\n", + "\n", + "Note: Topostats is an AFM imaging software package developed at the University of Sheffield which is used for filtering of AFM data. We desribe functions that perform operations similar to Topostats to clean the noise data from the blank files before adding it to the AFM_img.\n", + "\n", + "### Mathematics of PSD-Matched Noise Synthesis\n", + "\n", + "All three methods in the code utilize **Frequency-Domain Synthesis**. The core principle is that the height field $z(x, y)$ can be generated from a target Power Spectral Density (PSD) using the inverse Fourier Transform.\n", + "\n", + "#### 1. General Synthesis Workflow\n", + "For an output image of shape $(N_y, N_x)$:\n", + "1. **Define a PSD**: Let $S(f_x, f_y)$ be the target power spectrum.\n", + "2. **Generate Complex Spectrum**: A complex field $Z(f_x, f_y)$ is created in the frequency domain:\n", + " $$Z(f_x, f_y) = \\sqrt{S(f_x, f_y)} \\cdot e^{i \\phi(f_x, f_y)}$$\n", + " where $\\phi$ is a random phase drawn from a uniform distribution $U(0, 2\\pi)$.\n", + "3. **Inverse Transform**: The spatial noise $z(x, y)$ is the real part of the Inverse Fast Fourier Transform (IFFT) of $Z$.\n", + "4. **RMS Scaling**: The image is normalized such that its standard deviation matches the target Root Mean Square (RMS) roughness." + ] + }, + { + "cell_type": "code", + "execution_count": 235, + "id": "cell_code_06", + "metadata": { + "id": "cell_code_06" + }, + "outputs": [], + "source": [ + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# Parsing the .spm file for height data\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "\n", + "def robust_range(a:np.ndarray | list) -> tuple[float, float, float]:\n", + " \"\"\"Calculate the 1st and 99th percentiles of finite values in an array.\n", + "\n", + " This function provides a robust measure of the data range by ignoring\n", + " extreme outliers (the top and bottom 1%) as well as non-finite values\n", + " (NaNs and infinities).\n", + "\n", + " Parameters\n", + " ----------\n", + " a : np.ndarray | list\n", + " The input data array to be evaluated.\n", + "\n", + " Returns\n", + " -------\n", + " tuple[float, float, float]\n", + " A tuple containing:\n", + " - percentile_1: The 1st percentile of the finite data.\n", + " - percentile_99: The 99th percentile of the finite data.\n", + " - robust_spread: The difference between the 99th and 1st percentiles.\n", + "\n", + " Examples\n", + " --------\n", + " >>> a,b,c = robust_range(img)\n", + " >>> print(a,b,c)\n", + " 262 1023 761\n", + "\n", + " \"\"\"\n", + "\n", + " a = np.asarray(a, dtype=np.float32)\n", + " p1, p99 = np.percentile(a[np.isfinite(a)], [1, 99])\n", + " return float(p1), float(p99), float(p99 - p1)\n", + "\n", + "\n", + "def looks_like_afm_height(img: np.ndarray) -> bool:\n", + " \"\"\"Determine if an image array represents a valid AFM height map.\n", + "\n", + " This function checks if the dynamic range of the image (excluding\n", + " extreme outliers) is finite, strictly positive, and within a physically\n", + " sane upper bound.\n", + "\n", + " Parameters\n", + " ----------\n", + " img : np.ndarray\n", + " The 2D array representing the simulated or real AFM height map.\n", + "\n", + " Returns\n", + " -------\n", + " bool\n", + " True if the image has a valid, finite, and positive dynamic range;\n", + " False otherwise (e.g., if the array is flat, infinite, or all NaNs).\n", + "\n", + " Examples\n", + " --------\n", + " >>> Flag = looks_like_afm_height(img)\n", + " >>> print(Flag)\n", + " True\n", + "\n", + " \"\"\"\n", + "\n", + " p1, p99, rng = robust_range(img)\n", + " return np.isfinite(rng) and 0 < rng <= 1e9\n", + "\n", + "\n", + "def maybe_to_nm(img: np.ndarray) -> tuple[np.ndarray, str]:\n", + " \"\"\"Auto-convert from metres to nm if values look metre-scale.\n", + "\n", + " This function is used to convert the height map from metres to nm if the\n", + " measured height is in metres.\n", + "\n", + " Parameters\n", + " ----------\n", + " img : np.ndarray\n", + " The 2D array representing the AFM height map.\n", + "\n", + " Returns\n", + " -------\n", + " A tuple consisting of:\n", + " - np.ndarray\n", + " The image after the converion of the height map if needed.\n", + " - str\n", + " either as is or meters to nanometers depending on passed values.\n", + "\n", + " Examples\n", + " --------\n", + " >>> img = maybe_to_nm(img)\n", + " >>> print(img.shape)\n", + " (800, 800)\n", + "\n", + " \"\"\"\n", + "\n", + " p1, p99, rng = robust_range(img)\n", + " mx = max(abs(p1), abs(p99))\n", + " if mx < 1e-3:\n", + " return img.astype(np.float32) * 1e9, \"meters->nm (auto)\"\n", + " return img.astype(np.float32), \"as-is (nm or counts)\"\n", + "\n", + "\n", + "def parse_blocks(\n", + " filename: str | Path,\n", + " max_blocks: int = 128,\n", + ") -> tuple[bytes, str, list[dict]]:\n", + " \"\"\"Read a .spm file and parse binary data-block metadata.\n", + "\n", + " This function extracts the ASCII header from a Scanning Probe Microscopy\n", + " (SPM) file, locates the metadata blocks for the image data, and parses the\n", + " structural parameters required to read the raw binary data.\n", + "\n", + " Parameters\n", + " ----------\n", + " filename: str | Path\n", + " The path to the .spm file to be parsed.\n", + " max_blocks: int\n", + " The maximum number of blocks to parse.\n", + "\n", + " Returns\n", + " -------\n", + " tuple[bytes, str, list[dict]]\n", + " A tuple containing:\n", + " - raw: The raw binary data from the .spm file.\n", + " - header: The ASCII header from the .spm file.\n", + " - uniq: A list of dictionaries containing the parsed block metadata.\n", + "\n", + " Raises\n", + " ------\n", + " RuntimeError\n", + " If no 'Data offset' strings are found in the header.\n", + "\n", + " Examples\n", + " --------\n", + " >>> raw, header, blocks = parse_blocks(filename)\n", + " >>> print(type(raw), type(header), type(blocks))\n", + " \n", + "\n", + " \"\"\"\n", + "\n", + " raw = open(filename, \"rb\").read()\n", + " i_end = raw.find(b\"\\x1a\")\n", + " if i_end == -1:\n", + " i_end = min(len(raw), 400_000)\n", + " header = raw[:i_end].decode(\"latin1\", errors=\"ignore\")\n", + "\n", + " matches = [m.start() for m in re.finditer(r\"Data offset\", header)]\n", + " if not matches:\n", + " raise RuntimeError(\"No 'Data offset' found in header.\")\n", + "\n", + " blocks = []\n", + " for k, pos in enumerate(matches[:max_blocks]):\n", + " win = header[max(0, pos-2500): min(len(header), pos+2500)]\n", + "\n", + " def grab_int(key):\n", + " m = re.search(rf\"{re.escape(key)}\\s*:\\s*([0-9]+)\", win)\n", + " return int(m.group(1)) if m else None\n", + "\n", + " def grab_float(key):\n", + " pattern = (\n", + " rf\"{re.escape(key)}\\s*:\\s*\"\n", + " r\"([+-]?[0-9]*\\.?[0-9]+(?:[Ee][+-]?[0-9]+)?)\"\n", + " )\n", + " m = re.search(pattern, win)\n", + " return float(m.group(1)) if m else None\n", + "\n", + " name_candidate = re.findall(r\"@[^:\\n\\r]{0,40}:\\s*([^\\n\\r]{1,80})\", win)\n", + " name = name_candidate[-1].strip() if name_candidate else None\n", + "\n", + " off = grab_int(\"Data offset\")\n", + " length = grab_int(\"Data length\")\n", + " bpp = grab_int(\"Bytes/pixel\")\n", + " nx_b = grab_int(\"Samps/line\")\n", + " ny_b = grab_int(\"Number of lines\")\n", + " zscale = grab_float(\"Z scale\")\n", + " zoff = grab_float(\"Z offset\")\n", + "\n", + " if None in (off, length, bpp, nx_b, ny_b):\n", + " continue\n", + " blocks.append(dict(name=name or f\"block_{k}\",\n", + " off=off, length=length, bpp=bpp,\n", + " nx=nx_b, ny=ny_b,\n", + " zscale=zscale, zoff=zoff))\n", + "\n", + " uniq, seen = [], set()\n", + " for b in blocks:\n", + " if b[\"off\"] not in seen:\n", + " uniq.append(b); seen.add(b[\"off\"])\n", + " if not uniq:\n", + " raise RuntimeError(\"Found 'Data offset' strings\"\n", + " \" but no parseable blocks.\")\n", + " return raw, header, uniq\n", + "\n", + "\n", + "def read_block_candidates(\n", + " raw: bytes,\n", + " b: dict,\n", + ") -> list[tuple[str, np.ndarray]]:\n", + " \"\"\"Decode a binary data block using all plausible NumPy data types.\n", + "\n", + " This function attempts to parse the binary blob using all logical dtypes\n", + " for the given bytes-per-pixel and applies physical Z-scaling to the\n", + " results.\n", + "\n", + " Parameters\n", + " ----------\n", + " raw : bytes\n", + " The raw binary data from the .spm file.\n", + " b : dict\n", + " The parsed block metadata.\n", + "\n", + " Returns\n", + " -------\n", + " list[tuple[str, np.ndarray]]\n", + " A list of candidate tuples. Each tuple contains:\n", + " - dtype_str: The string representation of the data type.\n", + " - image_array: The decoded image array.\n", + "\n", + " Raises\n", + " ------\n", + " Runtime error\n", + " - Truncated block.\n", + "\n", + " Examples\n", + " --------\n", + " >>> candidates = read_block_candidates(raw, b)\n", + " >>> print(type(candidates))\n", + " \n", + "\n", + " \"\"\"\n", + "\n", + " off, length, bpp = b[\"off\"], b[\"length\"], b[\"bpp\"]\n", + " nx_b, ny_b = b[\"nx\"], b[\"ny\"]\n", + " blob = raw[off:off+length]\n", + " if len(blob) < length:\n", + " raise RuntimeError(\"Truncated block.\")\n", + "\n", + " n = nx_b * ny_b\n", + " cands = []\n", + " dtype_map = {2: [\"i2\", \"u2\"],\n", + " 4: [\"i4\", \"f4\"],\n", + " 1: [\"u1\"]}\n", + " for dt in dtype_map.get(bpp, []):\n", + " arr = np.frombuffer(blob, dtype=np.dtype(dt), count=n)\n", + " if arr.size != n:\n", + " continue\n", + " cands.append((dt, arr.reshape(ny_b, nx_b).astype(np.float32)))\n", + "\n", + " out = []\n", + " for dt, img in cands:\n", + " z = img\n", + " if b.get(\"zscale\") is not None:\n", + " z = z * np.float32(b[\"zscale\"])\n", + " if b.get(\"zoff\") is not None:\n", + " z = z + np.float32(b[\"zoff\"])\n", + " out.append((dt, z))\n", + " return out\n", + "\n", + "\n", + "def choose_best_height_image(\n", + " raw: bytes,\n", + " blocks: list[dict],\n", + " verbose: bool = True,\n", + ")-> tuple[dict, np.ndarray]:\n", + " \"\"\"Evaluate all data blocks to find the most plausible AFM height map.\n", + "\n", + " This function iterate all blocks and dtype candidates and then picks the\n", + " one that:\n", + " - passes looks_like_afm_height\n", + " - has the highest log-variance score\n", + " (which is done to favor candidates with more topographical detail)\n", + "\n", + " Parameters\n", + " ----------\n", + " raw : bytes\n", + " The raw binary data from the .spm file.\n", + " blocks : list[dict]\n", + " The parsed block metadata.\n", + " verbose : bool\n", + " Whether to print diagnostics.\n", + "\n", + " Returns\n", + " -------\n", + " tuple[dict, np.ndarray]\n", + "\n", + " Raises\n", + " ------\n", + " RuntimeError\n", + " If no suitable block is found.\n", + "\n", + " Examples\n", + " --------\n", + " >>> b, img = choose_best_height_image(raw, blocks)\n", + " >>> print(type(b), type(img))\n", + " \n", + "\n", + " \"\"\"\n", + "\n", + " best, best_score = None, -np.inf\n", + " for b in blocks:\n", + " try:\n", + " for dt, img in read_block_candidates(raw, b):\n", + " if not looks_like_afm_height(img):\n", + " continue\n", + " p1, p99, rng = robust_range(img)\n", + " var = float(np.var(img))\n", + " score = np.log10(var + 1e-9) - 0.001 * max(rng - 1e6, 0)\n", + " if score > best_score:\n", + " best_score = score\n", + " best = (b, dt, img, (p1, p99, rng, var))\n", + " except Exception:\n", + " continue\n", + "\n", + " if best is None:\n", + " raise RuntimeError(\"Could not find a\"\n", + " \"plausible AFM height image decode.\")\n", + " b, dt, img, stats = best\n", + " if verbose:\n", + " p1, p99, rng, var = stats\n", + " print(f\"Chosen block: {b['name']!r} {b['ny']}x{b['nx']} \"\n", + " f\"bpp={b['bpp']} decode={dt}\")\n", + " print(f\"Robust p1={p1:.3g}, p99={p99:.3g}, \"\n", + " f\"range={rng:.3g}, var={var:.3g}\")\n", + " return b, img\n", + "\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# TopoStats-like background / noise extraction\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "\n", + "def plane_remove(\n", + " z: np.ndarray,\n", + " mask: np.ndarray | None = None,\n", + ")-> np.ndarray:\n", + " \"\"\"Fit and subtract a first-order tilted plane from a 2D height map.\n", + "\n", + " This function performs background leveling by fitting a plane defined by\n", + " the equation z = ax + by + c to the image. If a mask is provided, the fit\n", + " is calculated only using the pixels where the mask is True (typically\n", + " representing the flat substrate).\n", + "\n", + " Parameters\n", + " ----------\n", + " z : np.ndarray\n", + " The 2D height map.\n", + " mask : np.ndarray | None, optional\n", + " A boolean mask of the same shape as z. If provided, the fit is\n", + " calculated only using the pixels where the mask is True.\n", + " This is useful for excluding features like DNA from the plane fit.\n", + " Defaults to None.\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray\n", + " The flattened height map.\n", + "\n", + " Examples\n", + " --------\n", + " >>> z_flat = plane_remove(z)\n", + " >>> print(z_flat.shape)\n", + " (800, 800)\n", + "\n", + " \"\"\"\n", + "\n", + " ny, nx = z.shape\n", + " Y, X = np.mgrid[0:ny, 0:nx]\n", + " A = np.c_[X.ravel(), Y.ravel(), np.ones(X.size)]\n", + " b = z.ravel()\n", + " if mask is not None:\n", + " m = mask.ravel().astype(bool)\n", + " A, b = A[m], b[m]\n", + " C, *_ = np.linalg.lstsq(A, b, rcond=None)\n", + " plane = (C[0]*X + C[1]*Y + C[2]).astype(np.float32)\n", + " return (z - plane).astype(np.float32)\n", + "\n", + "\n", + "def line_flatten_median(\n", + " z: np.ndarray,\n", + " mask: np.ndarray | None = None,\n", + ")-> np.ndarray:\n", + " \"\"\"Subtract per-row median (background pixels only if mask given).\n", + "\n", + " AFM images often exhibit horizontal stripes due to low-frequency noise or\n", + " z-axis drift during scanning. This function levels each scan line\n", + " independently by shifting its median value to zero.\n", + "\n", + " Parameters\n", + " ----------\n", + " z: np.ndarray\n", + " The 2D height map\n", + " mask: np.ndarray | None, optional\n", + " A boolean mask of the same shape as z. If provided,\n", + " the median is calculated only using the pixels where the mask is True.\n", + " This prevents features (like DNA) from biasing the\n", + " flattening of the background. Defaults to None.\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray\n", + " The flattened height map.\n", + "\n", + " Examples\n", + " --------\n", + " >>> z_flat = line_flatten_median(z)\n", + " >>> print(z_flat.shape)\n", + " (800, 800)\n", + "\n", + " \"\"\"\n", + "\n", + " out = z.astype(np.float32, copy=True)\n", + " for i in range(out.shape[0]):\n", + " if mask is None or not np.any(mask[i]):\n", + " med = np.median(out[i])\n", + " else:\n", + " med = np.median(out[i, mask[i]])\n", + " out[i] -= np.float32(med)\n", + " return out\n", + "\n", + "\n", + "def feature_mask(\n", + " z: np.ndarray,\n", + " smooth_sigma_px: float = 3.0,\n", + " thresh_sigma: float = 3.0,\n", + " dilate_px: int = 4,\n", + ")-> np.ndarray:\n", + " \"\"\"Detects topographical features as pixels deviating by a threshold.\n", + "\n", + " This function identifies pixels that deviate significantly from a smoothed\n", + " local background. It uses the Median Absolute Deviation (MAD) to estimate\n", + " the noise floor, making it robust against the features it is trying to\n", + " detect.\n", + "\n", + " Parameters\n", + " ----------\n", + " z : np.ndarray\n", + " The 2D height map.\n", + " smooth_sigma_px : float, optional\n", + " The smoothing width in pixels. Defaults to 3.0.\n", + " thresh_sigma : float, optional\n", + " The number of standard deviations above the median to consider a pixel\n", + " as a feature. Defaults to 3.0.\n", + " dilate_px : int, optional\n", + " The radius of circular footprint to dilate the feature mask.\n", + " Defaults to 4.\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray\n", + " A boolean mask where true indicates a detected feature\n", + "\n", + " Examples\n", + " --------\n", + " >>> feat = feature_mask(z)\n", + " >>> print(feat.shape, feat.dtype)\n", + " (800, 800) bool\n", + "\n", + " \"\"\"\n", + "\n", + " z_s = gaussian_filter(z, sigma=float(smooth_sigma_px)).astype(np.float32)\n", + " resid = (z - z_s).astype(np.float32)\n", + " med = float(np.median(resid))\n", + " mad = float(np.median(np.abs(resid - med)))\n", + " sig = 1.4826 * mad if mad > 1e-12 else float(np.std(resid) + 1e-12)\n", + " feat = np.abs(resid - med) > (float(thresh_sigma) * sig)\n", + " if dilate_px and dilate_px > 0:\n", + " r = int(dilate_px)\n", + " yy, xx = np.ogrid[-r:r+1, -r:r+1]\n", + " fp = (xx*xx + yy*yy) <= r*r\n", + " feat = grey_dilation(feat.astype(np.uint8), footprint=fp) > 0\n", + " return feat\n", + "\n", + "\n", + "def inpaint_simple(\n", + " z: np.ndarray,\n", + " mask: np.ndarray,\n", + " smooth_sigma_px: float = 8.0,\n", + ") -> np.ndarray:\n", + " \"\"\"Replace masked regions with a smooth estimate of the local background.\n", + "\n", + " This function calculates a heavily blurred version of the original image to\n", + " serve as a background proxy and patches the masked areas with this\n", + " estimate.\n", + "\n", + " Parameters\n", + " ----------\n", + " z : np.ndarray\n", + " The 2D height map.\n", + " mask : np.ndarray\n", + " A boolean mask where True indicates pixels to be inpainted (features)\n", + " smooth_sigma_px : float, optional\n", + " The sigma value for the gaussian filter.\n", + " Higher value resutls in smoother inpainted images. Defaults to 8.0.\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray\n", + " The inpainted height\n", + "\n", + " Examples\n", + " --------\n", + " >>> z_bg = inpaint_simple(z, feat)\n", + " >>> print(z_bg.shape)\n", + " (800, 800)\n", + "\n", + " \"\"\"\n", + "\n", + " bg = gaussian_filter(z, sigma=float(smooth_sigma_px)).astype(np.float32)\n", + " out = z.copy()\n", + " out[mask] = bg[mask]\n", + " return out\n", + "\n", + "\n", + "def bandpass_noise(\n", + " z: np.ndarray,\n", + " low_sigma_px: float = 1.0,\n", + " high_sigma_px: float = 30.0,\n", + ") -> np.ndarray:\n", + " \"\"\"Performs bandpass filtering on the noise image.\n", + "\n", + " This function performs a bandpass filter by calculating the difference\n", + " between two Gaussian-blurred versions of the same image. It effectively\n", + " removes:\n", + " 1. High-frequency noise: Suppressed by the `low_sigma` blur.\n", + " 2. Low-frequency trends: (like tilt or bowing) Removed by subtracting\n", + " the `high_sigma` blur.\n", + "\n", + " Parameters\n", + " ----------\n", + " z : np.ndarray\n", + " The 2D height\n", + " low_sigma_px : float, optional\n", + " The sigma value for gaussian filter defining the high frequency cutoff.\n", + " Defaults to 1.0.\n", + " high_sigma_px : float, optional\n", + " The sigma value for gaussian filter defining the low frequency cutoff.\n", + " Defaults to 30.0.\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray\n", + " The bandpassed height map.\n", + "\n", + " Examples\n", + " --------\n", + " >>> tex = bandpass_noise(z)\n", + " >>> print(tex.shape)\n", + " (800, 800)\n", + "\n", + " \"\"\"\n", + "\n", + " low = gaussian_filter(z, sigma=float(low_sigma_px)).astype(np.float32)\n", + " high = gaussian_filter(z, sigma=float(high_sigma_px)).astype(np.float32)\n", + " return (low - high).astype(np.float32)\n", + "\n", + "\n", + "def extract_topostats_like_noise(\n", + " z_in: np.ndarray,\n", + " median_size: int = 3,\n", + " bg_quantile: float = 40.0,\n", + " feature_sigma_px: float = 3.0,\n", + " feature_thresh_sigma: float = 3.0,\n", + " feature_dilate_px: int = 4,\n", + " inpaint_sigma_px: float = 10.0,\n", + " band_low_sigma_px: float = 0.8,\n", + " band_high_sigma_px: float = 35.0,\n", + " target_rms_nm: float | None = None,\n", + " apply_plane_remove: bool = True,\n", + " apply_line_flatten: bool = True,\n", + " apply_bandpass: bool = True,\n", + ") -> tuple[float, np.ndarray, np.ndarray, np.ndarray]:\n", + " \"\"\"Execute the full noise-extraction pipeline on an AFM height map.\n", + "\n", + " This function isolates the pure substrate noise texture by leveling the\n", + " image (plane flatten and line flatten), masking out topographical features\n", + " (detect features), inpainting those regions, and applying a bandpass\n", + " filter.\n", + " The resulting image can be rescaled to a target RMS value.\n", + " The resulting texture can be used to augment synthetic datasets.\n", + "\n", + " Parameters\n", + " ----------\n", + " z_in : np.ndarray\n", + " The 2D height map.\n", + " median_size : int, optional\n", + " The size of the median filter to apply. Defaults to 3.\n", + " bg_quantile : float, optional\n", + " The quantile to used to generate a rough initial background guess for the\n", + " preliminary plane and line leveling. Defaults to 40.0.\n", + " feature_sigma_px : float, optional\n", + " The gaussian sigma for background estimation for the feature mask.\n", + " Defaults to 3.0.\n", + " feature_thresh_sigma : float, optional\n", + " The number of standard deviations above the median to consider a pixel as\n", + " a feature. Defaults to 3.0.\n", + " feature_dilate_px : int, optional\n", + " The radius of curcular footprint to dilate the feature mask. Defaults to\n", + " 4.\n", + " inpaint_sigma_px : float, optional\n", + " The sigma value for the gaussian filter. Higher value results in smoother\n", + " inpainted image. Defaults to 10.0.\n", + " band_low_sigma_px : float, optional\n", + " The sigma value for gaussian filter defining the high frequency cutoff.\n", + " Defaults to 0.8.\n", + " band_high_sigma_px : float, optional\n", + " The sigma value for gaussian filter defining the low frequency cutoff.\n", + " Defaults to 35.0.\n", + " target_rms_nm: float | None, optional\n", + " If provided, rescales the extracted noise textureto match this target RMS\n", + " roughness. Defaults to None.\n", + " apply_plane_remove : bool, optional\n", + " Whether to apply the plane remove step. Defaults to True.\n", + " apply_line_flatten : bool, optional\n", + " Whether to apply the line flatten step. Defaults to True.\n", + " apply_bandpass : bool, optional\n", + " Whether to apply the bandpass step. Defaults to True.\n", + "\n", + " Returns\n", + " -------\n", + " tuple[float, np.ndarray, np.ndarray, np.ndarray]\n", + " A tuple containing:\n", + " - rms_nm: The RMS roughness of the extracted noise texture.\n", + " - noise_texture: The extracted, zero mean noise texture.\n", + " - z_flat: The flattened height map.\n", + " - feature_mask: A boolean mask where true indicates a detected feature.\n", + "\n", + " Examples\n", + " --------\n", + " >>> rms_nm, noise_tex, z_flat, feat = extract_topostats_like_noise(z)\n", + " >>> print(rms_nm)\n", + " 0.06\n", + " >>> print(noise_tex.shape)\n", + " (800, 800)\n", + " >>> print(z_flat.shape)\n", + " (800, 800)\n", + " >>> print(feat.shape)\n", + " (800, 800)\n", + "\n", + " \"\"\"\n", + "\n", + " z = z_in.astype(np.float32)\n", + "\n", + " if median_size and median_size > 1:\n", + " z = median_filter(z, size=int(median_size)).astype(np.float32)\n", + "\n", + " q = np.percentile(z, float(bg_quantile))\n", + " bg0 = z <= q\n", + "\n", + " z_flat = z.copy()\n", + "\n", + " if apply_plane_remove:\n", + " z_flat = plane_remove(z_flat, mask=bg0)\n", + "\n", + " if apply_line_flatten:\n", + " z_flat = line_flatten_median(z_flat, mask=bg0)\n", + "\n", + " feat = feature_mask(\n", + " z_flat,\n", + " smooth_sigma_px=feature_sigma_px,\n", + " thresh_sigma=feature_thresh_sigma,\n", + " dilate_px=feature_dilate_px,\n", + " )\n", + "\n", + " z_bg = inpaint_simple(\n", + " z_flat,\n", + " feat,\n", + " smooth_sigma_px=inpaint_sigma_px,\n", + " )\n", + "\n", + " if apply_bandpass:\n", + " tex = bandpass_noise(\n", + " z_bg,\n", + " low_sigma_px=band_low_sigma_px,\n", + " high_sigma_px=band_high_sigma_px,\n", + " )\n", + " else:\n", + " tex = z_bg.astype(np.float32)\n", + "\n", + " bg = ~feat\n", + " rms = float(np.std(tex[bg])) if np.any(bg) else float(np.std(tex))\n", + "\n", + " if target_rms_nm is not None:\n", + " target = float(target_rms_nm)\n", + " if rms > 1e-12:\n", + " tex *= target / rms\n", + " rms = target\n", + "\n", + " return (\n", + " rms,\n", + " tex.astype(np.float32),\n", + " z_flat.astype(np.float32),\n", + " feat.astype(bool),\n", + " )\n", + "\n", + "\n", + "def tile_or_crop(\n", + " tex: np.ndarray,\n", + " out_shape: tuple[int, int],\n", + " seed: int | None = 0,\n", + ")-> np.ndarray:\n", + " \"\"\"Tile a texture array and extract a deterministic random crop.\n", + "\n", + " This function ensures that an extracted background noise texture can be\n", + " resized to fit any target simulated image size. If the texture is smaller\n", + " than the target, it is tiled (repeated) to cover the area. A random crop is\n", + " then taken to prevent obvious repeating patterns at the origin.\n", + "\n", + " Parameters\n", + " ----------\n", + " tex : np.ndarray\n", + " The 2D height map\n", + " out_shape : tuple[int, int]\n", + " The target output shape.\n", + " seed : int | None, optional\n", + " The random seed. Defaults to 0.\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray\n", + " The resized and cropped noise texture.\n", + "\n", + " Examples\n", + " --------\n", + " >>> tex = tile_or_crop(tex, (ny, nx))\n", + " >>> print(tex.shape)\n", + " (800, 800)\n", + "\n", + " \"\"\"\n", + "\n", + " ty, tx = tex.shape\n", + " oy, ox = out_shape\n", + " if (ty, tx) == (oy, ox):\n", + " return tex\n", + " tiled = np.tile(tex, (int(np.ceil(oy / ty)), int(np.ceil(ox / tx))))\n", + " rng = np.random.default_rng(seed)\n", + " y0 = int(rng.integers(0, tiled.shape[0] - oy + 1))\n", + " x0 = int(rng.integers(0, tiled.shape[1] - ox + 1))\n", + " return tiled[y0:y0+oy, x0:x0+ox].astype(np.float32)\n", + "\n", + "\n", + "def load_blank_spm_noise(\n", + " blank_path: str | Path,\n", + " target_rms_nm: float = 0.06,\n", + " verbose: bool = True,\n", + " apply_plane_remove: bool = USE_PLANE_REMOVE,\n", + " apply_line_flatten: bool = USE_LINE_FLATTEN,\n", + " apply_bandpass: bool = USE_BANDPASS_FILTER,\n", + ") -> tuple[float, np.ndarray, dict]:\n", + " \"\"\"Load an SPM file and extract a calibrated background noise texture.\n", + "\n", + " This high-level function handles the full lifecycle of noise extraction:\n", + " 1. Parsing the Bruker .spm binary and metadata.\n", + " 2. Heuristically selecting the best height channel.\n", + " 3. Calibrating raw digital units to physical nanometers.\n", + " 4. Leveling, masking, and bandpass-filtering the substrate noise.\n", + "\n", + " Parameters\n", + " ----------\n", + " blank_path : str | Path\n", + " The path to the blank .spm file.\n", + " target_rms_nm : float, optional\n", + " The target RMS roughness of the extracted noise texture.\n", + " Defaults to 0.06.\n", + " verbose : bool, optional\n", + " Whether to print progress messages and diagnostic statistics.\n", + " Defaults to True.\n", + " apply_plane_remove: bool, optional\n", + " Whether or not to perform plane removal on the image. Defaults to \n", + " USE_PLANE_REMOVE. \n", + "\n", + " Returns\n", + " -------\n", + " tuple[float, np.ndarray, dict]\n", + " A tuple containing:\n", + " - rms_nm: The RMS roughness of the extracted noise texture.\n", + " - noise_texture: The extracted, zero mean noise texture.\n", + " - diagnostics_dict: A dictionary containing diagnostic information.\n", + "\n", + " Examples\n", + " --------\n", + " >>> rms_nm, noise_tex, diag = load_blank_spm_noise(blank_path)\n", + " >>> print(rms_nm)\n", + " 0.06\n", + " >>> print(noise_tex.shape)\n", + " (800, 800)\n", + " >>> print(diag['flattened'].shape)\n", + " (800, 800)\n", + " >>> print(diag['feature_mask'].shape)\n", + " (800, 800)\n", + "\n", + " \"\"\"\n", + "\n", + " raw, header, blocks = parse_blocks(blank_path)\n", + " b, img0 = choose_best_height_image(raw, blocks, verbose=verbose)\n", + " img_nm, unit_note = maybe_to_nm(img0)\n", + " if verbose:\n", + " print(\"Loaded via parser:\", img0.shape, \"| units:\", unit_note)\n", + "\n", + " rms_nm, noise_tex, z_flat, feat = extract_topostats_like_noise(\n", + " img_nm,\n", + " median_size=3,\n", + " bg_quantile=45,\n", + " feature_sigma_px=3.0,\n", + " feature_thresh_sigma=3.0,\n", + " feature_dilate_px=6,\n", + " inpaint_sigma_px=10.0,\n", + " band_low_sigma_px=0.7,\n", + " band_high_sigma_px=40.0,\n", + " target_rms_nm=target_rms_nm,\n", + " )\n", + " diag = {\"flattened\": z_flat, \"feature_mask\": feat,\n", + " \"height_nm\": img_nm, \"unit_note\": unit_note}\n", + " if verbose:\n", + " print(f\"Extracted noise RMS (bg): {rms_nm:.4f} nm | \"\n", + " f\"tex shape: {noise_tex.shape}\")\n", + " return rms_nm, noise_tex, diag\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# PSD-based fallback noise synthesis\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "\n", + "TARGET_SHAPE = (NY, NX) #To match the shape of the AFM_img\n", + "#Safety buffer to ensure no division by 0 or square roots producing NaN values\n", + "EPS = 1e-12\n", + "\n", + "\n", + "def load_model(\n", + " path: str | Path = MODEL_PATH,\n", + ") -> dict[str, np.ndarray]:\n", + " \"\"\"\n", + " Load the Power Spectral Density (PSD) noise model\n", + " from a compressed archive.\n", + "\n", + " The model typically contains the statistical distribution of substrate\n", + " roughness in the frequency domain, allowing for the generation of\n", + " synthetic noise that matches the 'color' and texture of the substrate.\n", + "\n", + " Parameters\n", + " ----------\n", + " path : str | Path, optional\n", + " The path to the compressed archive containing the PSD model.\n", + "\n", + " Returns\n", + " -------\n", + " dict[str, np.ndarray]\n", + " A dictionary containing the PSD model components namely:\n", + " - \"log_psd_mean\": The mean of the log-transformed radial PSD.\n", + " - \"log_psd_std\": The standard deviation of the\n", + " log-transformed radial PSD.\n", + " - \"radial_freq\": The spatial frequency coordinates.\n", + " - \"rms_values_nm\": RMS values associated with the training set.\n", + "\n", + " Examples\n", + " --------\n", + " >>> model = load_model()\n", + " >>> print(type(model))\n", + " \n", + "\n", + " \"\"\"\n", + "\n", + " data = np.load(path)\n", + " return {\n", + " \"log_psd_mean\": data[\"log_psd_mean\"].astype(np.float32),\n", + " \"log_psd_std\": data[\"log_psd_std\"].astype(np.float32),\n", + " \"radial_freq\": data[\"radial_freq\"].astype(np.float32),\n", + " \"rms_values_nm\": data[\"rms_values_nm\"].astype(np.float32),\n", + " }\n", + "\n", + "\n", + "def generate_noise(\n", + " seed: int,\n", + " target_shape: tuple[int, int] = TARGET_SHAPE,\n", + " target_rms_nm: float | None = TARGET_NOISE_RMS_NM,\n", + " method: str = \"mean_full2d\",\n", + " std_scale: float = 1.0,\n", + " model: dict | None = None,\n", + " model_path: str | Path | None = MODEL_PATH,\n", + ") -> np.ndarray:\n", + " \"\"\"\n", + " Generate a single random AFM-like background noise image from the PSD.\n", + "\n", + " This function performs Fourier synthesis to create textures that match\n", + " the spatial frequency characteristics of the PSD model provided.\n", + "\n", + " Parameters\n", + " ----------\n", + " seed : int\n", + " RNG seed for reproducibility.\n", + " target_shape : tuple[int, int]\n", + " Output image shape (rows, cols).\n", + " The PSD is resized automatically if it differs\n", + " from the shape used when building the model. Defaults to TARGET_SHAPE.\n", + " target_rms_nm : float | None\n", + " RMS amplitude in nm.\n", + " If None a value is randomly taken from the blank-file ensemble.\n", + " Defaults to TARGET_NOISE_RMS_NM.\n", + " method : str\n", + " 'mean_full2d' -- mean log-PSD;\n", + " variance comes only from random phase (recommended).\n", + " 'lognormal_full2d' -- Samples a new PSD\n", + " from the log-normal distribution. (more sample to sample variation)\n", + " 'empirical_radial' -- isotropic synthesis from the mean radial PSD.\n", + " std_scale : float\n", + " Multiplier for the PSD on log_psd_std\n", + " for lognormal method (>1 -> more variation).\n", + " model : dict | None\n", + " Pre-loaded model dict. If None, loaded from model_path on each call.\n", + " model_path : str | Path | None\n", + " Path to the .npz file (used only when model is None).\n", + "\n", + " Returns\n", + " -------\n", + " z: np.ndarray\n", + "\n", + " Raises\n", + " ------\n", + " ValueError\n", + " If an unknown method is provided.\n", + "\n", + " Examples\n", + " --------\n", + " >>> z = generate_noise(seed=42)\n", + " >>> print(z.shape)\n", + " (800, 800)\n", + "\n", + " \"\"\"\n", + "\n", + " if model is None:\n", + " model = load_model(model_path)\n", + "\n", + " rng = np.random.default_rng(int(seed))\n", + " out_shape = tuple(target_shape)\n", + "\n", + " if method == \"mean_full2d\":\n", + " psd_sample = np.exp(model[\"log_psd_mean\"])\n", + "\n", + " elif method == \"lognormal_full2d\":\n", + " mu= model[\"log_psd_mean\"]\n", + " noise = rng.standard_normal(mu.shape).astype(np.float32)\n", + " psd_sample = np.exp(mu + std_scale * mu * noise)\n", + "\n", + " elif method == \"empirical_radial\":\n", + " mu = model[\"log_psd_mean\"]\n", + " radial_psd = np.exp(mu.mean(axis=1))\n", + " radial_freq_for_interp = np.abs(np.fft.fftfreq(mu.shape[0], d=1.0))\n", + "\n", + " fy = np.fft.fftfreq(out_shape[0], d=1.0)\n", + " fx = np.fft.rfftfreq(out_shape[1], d=1.0)\n", + " fy2d, fx2d = np.meshgrid(fy, fx, indexing=\"ij\")\n", + " kr = np.sqrt(fy2d ** 2 + fx2d ** 2)\n", + "\n", + " psd_sample = np.interp(\n", + " kr.ravel(),\n", + " radial_freq_for_interp,\n", + " radial_psd,\n", + " left=float(radial_psd[0]),\n", + " right=float(radial_psd[-1]),\n", + " ).reshape(kr.shape).astype(np.float32)\n", + "\n", + " else:\n", + " raise ValueError(\n", + " f\"Unknown method {method!r}. \"\n", + " \"Choose 'mean_full2d', 'lognormal_full2d', or 'empirical_radial'.\"\n", + " )\n", + "\n", + " psd_ny, psd_nx = psd_sample.shape\n", + " out_ny, out_nx = out_shape\n", + " rfft_nx = out_nx // 2 + 1\n", + "\n", + " if (psd_ny, psd_nx) != (out_ny, rfft_nx):\n", + " from scipy.ndimage import zoom\n", + " psd_sample = zoom(psd_sample, (out_ny / psd_ny, rfft_nx / psd_nx),\n", + " order=1)\n", + "\n", + " psd_sample = psd_sample.astype(np.float32)\n", + "\n", + " phase = rng.uniform(0.0, 2.0 * np.pi, size=psd_sample.shape)\n", + " spec = np.sqrt(np.maximum(psd_sample, EPS)) * np.exp(1j * phase)\n", + "\n", + " z = np.fft.irfft2(spec, s=out_shape).real.astype(np.float32)\n", + " z -= np.float32(np.mean(z))\n", + " rmsv = model[\"rms_values_nm\"]\n", + " trmsf = float(target_rms_nm)\n", + " target = float(rng.choice(rmsv)) if target_rms_nm is None else trmsf\n", + " cur = float(np.std(z))\n", + " if cur > EPS:\n", + " z *= target / cur\n", + "\n", + " return z\n", + "\n", + "def random_transform_noise_texture(\n", + " tex: np.ndarray,\n", + " seed: int,\n", + ") -> np.ndarray:\n", + " \"\"\"Apply a deterministic random affine transform to a noise texture.\n", + "\n", + " This function generates a reproducible random transformation of an input\n", + " texture using the provided seed. The transformation includes rotation,\n", + " anisotropic scaling, translation, optional vertical and horizontal flips,\n", + " and a final amplitude jitter.\n", + " It is intended to produce visually distinct noise realizations from a\n", + " single acquired blank SPM texture, while preserving the overall texture\n", + " statistics.\n", + "\n", + " Parameters\n", + " ----------\n", + " tex: np.ndarray\n", + " Input noise texture of shape (H, W).\n", + " seed: int\n", + " Random seed controlling the random transformation.\n", + "\n", + " Returns\n", + " -------\n", + " out: np.ndarray\n", + " Transformed noise texture of shape (H, W).\n", + "\n", + " Examples\n", + " --------\n", + " >>> transformed = random_transform_noise_texture(tex, seed=42)\n", + " transformed\n", + " >>> transformed.shape == tex.shape\n", + " True\n", + "\n", + " \"\"\"\n", + "\n", + " rng = np.random.default_rng(int(seed))\n", + " tex = np.asarray(tex, dtype=np.float32)\n", + "\n", + " theta = np.deg2rad(float(rng.uniform(0.0, 360.0)))\n", + " base_scale = float(rng.uniform(0.85, 1.15))\n", + " anis = float(rng.uniform(0.85, 1.15))\n", + " sx, sy = base_scale * anis, base_scale / anis\n", + "\n", + " c, s = float(np.cos(theta)), float(np.sin(theta))\n", + " A = np.array([[c*sx, -s*sy], [s*sx, c*sy]], dtype=np.float32)\n", + " M = np.linalg.inv(A).astype(np.float32)\n", + "\n", + " h, w = tex.shape\n", + " center = np.array([(h-1)/2.0, (w-1)/2.0], dtype=np.float32)\n", + " t = np.array([float(rng.uniform(-0.15*h, 0.15*h)),\n", + " float(rng.uniform(-0.15*w, 0.15*w))], dtype=np.float32)\n", + " offset = center - M @ (center + t)\n", + "\n", + " out = affine_transform(tex, matrix=M, offset=offset,\n", + " output_shape=tex.shape, order=1,\n", + " mode=\"wrap\", prefilter=False).astype(np.float32)\n", + "\n", + " if bool(rng.integers(0, 2)):\n", + " out = out[::-1, :]\n", + " if bool(rng.integers(0, 2)):\n", + " out = out[:, ::-1]\n", + " out *= float(rng.uniform(0.90, 1.10))\n", + " return out.astype(np.float32)\n", + "\n", + "\n", + "def sample_noise_image(\n", + " noise_source: str,\n", + " noise_asset: dict | np.ndarray | None,\n", + " seed: int,\n", + " out_shape: tuple[int, int],\n", + " target_rms_nm: float | None,\n", + ") -> np.ndarray | None:\n", + " \"\"\"Return a per-sample noise image from either blank.spm or PSD fallback.\n", + "\n", + " Parameters\n", + " ----------\n", + " noise_source : str\n", + " 'blank_spm' or 'psd_model'\n", + " noise_asset : dict | np.ndarray | None\n", + " If 'blank_spm', this is the 2D texture array.\n", + " If 'psd_model', this is the dictionary containing PSD statistics.\n", + " seed : int\n", + " RNG seed for reproducibility.\n", + " out_shape : tuple[int, int]\n", + " The (rows, cols) of the desired height map.\n", + " target_rms_nm : float | None\n", + " If provided, rescales the extracted noise texture\n", + " to match this target RMS roughness.\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray | None\n", + " The per-sample noise image or None if disabled.\n", + "\n", + " Examples\n", + " --------\n", + " >>> noise_tex = sample_noise_image(noise_source, noise_asset,\n", + " seed, out_shape, target_rms_nm)\n", + " >>> print(noise_tex.shape)\n", + " (800, 800)\n", + "\n", + " \"\"\"\n", + "\n", + " if noise_asset is None:\n", + " return None\n", + "\n", + " if noise_source == \"blank_spm\":\n", + " noise_tex = random_transform_noise_texture(noise_asset, seed=seed)\n", + " return tile_or_crop(noise_tex, out_shape, seed=seed).astype(np.float32)\n", + "\n", + " if noise_source == \"psd_model\":\n", + " return generate_noise(\n", + " seed=seed,\n", + " target_shape=out_shape,\n", + " target_rms_nm=target_rms_nm,\n", + " method=PSD_NOISE_METHOD,\n", + " std_scale=PSD_NOISE_STD_SCALE,\n", + " model=noise_asset,\n", + " ).astype(np.float32)\n", + "\n", + " return None\n" + ] + }, + { + "cell_type": "markdown", + "id": "cell_md_07", + "metadata": { + "id": "cell_md_07" + }, + "source": [ + "## 8. DNA Ground-Truth Mask\n", + "Now that we have produced the AFM_img and added noise to it, we can generate the ground truth mask for the DNA chain, which is useful for training of machine learning models for classification and segmentation.\n", + "\n", + "The functions described here perform rasterization of the closed bead polyline into a binary mask using the same coordinate mapping as the AFM renderer, then dilates with a disk footprint. So, it takes the coordinates that are being used to generate the chain, and uses those to create the mask, thus removing any influence of the noise on the mask.\n", + "\n", + "We also dilate the mask by a value of **DNA_MASK_DILATE_PX** to ensure that the mask has enough width for optimal training." + ] + }, + { + "cell_type": "code", + "execution_count": 236, + "id": "cell_code_07", + "metadata": { + "id": "cell_code_07" + }, + "outputs": [], + "source": [ + "def nm_to_px(\n", + " coords_xy_nm: np.ndarray,\n", + " extent: tuple[float, float, float, float],\n", + " nx: int,\n", + " ny: int,\n", + ") -> tuple[np.ndarray, np.ndarray]:\n", + " \"\"\"Map (x, y) coordinates in nanometres to integer pixel indices (ix, iy).\n", + "\n", + " Linearly maps each coordinate from the physical extent to the discrete\n", + " pixel grid, then clips to valid index bounds.\n", + "\n", + " Parameters\n", + " ----------\n", + " coords_xy_nm : np.ndarray\n", + " The (x, y) coordinates in nanometres.\n", + " extent : tuple[float, float, float, float]\n", + " The physical extent (xmin, xmax, ymin, ymax) in nanometres.¨\n", + " nx : int\n", + " The number of pixels in the x-direction.\n", + " ny : int\n", + " The number of pixels in the y-direction.\n", + "\n", + " Returns\n", + " -------\n", + " ix, iy : tuple[np.ndarray, np.ndarray]\n", + " The integer pixel indices which are:\n", + " - ix: The x-coordinate indices.\n", + " - iy: The y-coordinate indices.\n", + "\n", + " Examples\n", + " --------\n", + " >>> ix, iy = nm_to_px(coords_xy_nm, extent, nx, ny)\n", + " >>> print(ix.dtype, iy.dtype)\n", + " int32 int32\n", + "\n", + " \"\"\"\n", + "\n", + " x = coords_xy_nm[:, 0]; y = coords_xy_nm[:, 1]\n", + " xmin, xmax, ymin, ymax = extent\n", + " ix = np.clip(((x - xmin) / (xmax - xmin) * (nx - 1)).astype(np.int32),\n", + " 0, nx - 1)\n", + " iy = np.clip(((y - ymin) / (ymax - ymin) * (ny - 1)).astype(np.int32),\n", + " 0, ny - 1)\n", + " return ix, iy\n", + "\n", + "\n", + "def rasterize_closed_polyline_mask(\n", + " coords: np.ndarray,\n", + " extent: tuple[float, float, float, float],\n", + " nx: int,\n", + " ny: int,\n", + ") -> np.ndarray:\n", + " \"\"\"Rasterize a closed bead polyline into a 1-pixel-wide binary mask.\n", + "\n", + " Each consecutive bead pair (including the wrap-around from the last bead\n", + " back to the first) is drawn onto the grid using dense linear interpolation\n", + " along the segment. Duplicate pixels that would arise at segment junctions\n", + " are de-duplicated before writing.\n", + "\n", + " Parameters\n", + " ----------\n", + " coords : np.ndarray\n", + " Array of shape (N, 3) or (N, 2) containing bead positions in\n", + " nanometres. Only the first two columns (x, y) are used.\n", + " extent : tuple[float, float, float, float]\n", + " The physical bounding box (xmin, xmax, ymin, ymax) in nanometres.\n", + " nx : int\n", + " The number of pixels in the x-axis.\n", + " ny : int\n", + " The number of pixels in the y-axis.\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray\n", + " A binary mask of shape (ny, nx),\n", + " with True at every pixel where the polyline is present\n", + " and False everywhere else.\n", + "\n", + " Examples\n", + " --------\n", + " >>> mask = rasterize_closed_polyline_mask(coords, extent, nx=512, ny=512)\n", + " >>> print(mask.shape, mask.dtype)\n", + " (512, 512) bool\n", + "\n", + " \"\"\"\n", + "\n", + " coords = np.asarray(coords, dtype=np.float32)\n", + " ix, iy = nm_to_px(coords[:, :2], extent, nx, ny)\n", + " out = np.zeros((ny, nx), dtype=bool)\n", + " npts = len(ix)\n", + " for k in range(npts):\n", + " k2 = (k + 1) % npts\n", + " x0, y0 = int(ix[k]), int(iy[k])\n", + " x1, y1 = int(ix[k2]), int(iy[k2])\n", + " n_seg = int(max(abs(x1 - x0), abs(y1 - y0)) + 1)\n", + " if n_seg <= 1:\n", + " out[y0, x0] = True\n", + " continue\n", + " xs = np.linspace(x0, x1, n_seg).astype(np.int32)\n", + " ys = np.linspace(y0, y1, n_seg).astype(np.int32)\n", + " if xs.size > 1:\n", + " keep = np.ones(xs.shape[0], dtype=bool)\n", + " keep[1:] = (xs[1:] != xs[:-1]) | (ys[1:] != ys[:-1])\n", + " xs, ys = xs[keep], ys[keep]\n", + " out[ys, xs] = True\n", + " return out\n", + "\n", + "\n", + "def make_dna_mask_from_beads(\n", + " coords: np.ndarray,\n", + " extent: tuple[float, float, float, float],\n", + " nx: int,\n", + " ny: int,\n", + " dilate_px: int = 3,\n", + ") -> np.ndarray:\n", + " \"\"\"Build a binary DNA segmentation mask from bead coordinates.\n", + "\n", + " Rasterizes the closed bead polyline into a 1-pixel-wide line mask and\n", + " optionally dilates it by a disk of radius ``dilate_px`` pixels to produce a\n", + " mask wide enough for robust segmentation training.\n", + "\n", + " Parameters\n", + " ----------\n", + " coords : np.ndarray\n", + " Array of shape (N, 3) or (N,2) containing bead positions in nanometres.\n", + " Only the first two columns (x, y) are used.\n", + " extent : tuple[float, float, float, float]\n", + " The physical bounding box (xmin, xmax, ymin, ymax) in nanometres.\n", + " nx : int\n", + " The number of pixels in the x-axis.\n", + " ny : int\n", + " The number of pixels in the y-axis.\n", + " dilate_px : int, optional\n", + " Radius in pixels of the disk structuring element used to dilate\n", + " the rasterized line. Set to 0 to skip dilation. Defaults to 3.\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray\n", + " uint8 binary mask of shape (ny, nx)\n", + " with values 0 (background) or 1 (DNA).\n", + "\n", + " Examples\n", + " --------\n", + " >>> mask = make_dna_mask_from_beads(coords, extent, nx=512, ny=512,\n", + " dilate_px=DNA_MASK_DILATE_PX)\n", + " >>> print(mask.shape)\n", + " (512, 512)\n", + "\n", + " \"\"\"\n", + "\n", + " line = rasterize_closed_polyline_mask(coords, extent, nx, ny)\n", + " if dilate_px and dilate_px > 0:\n", + " fdp = float(dilate_px)\n", + " line = binary_dilation(line, structure=disk_footprint(fdp))\n", + " return line.astype(np.uint8)" + ] + }, + { + "cell_type": "markdown", + "id": "cell_md_08", + "metadata": { + "id": "cell_md_08" + }, + "source": [ + "## 9. Crossing Detection & Crossing Mask\n", + "\n", + "The functions in this cell decribe how crossings are detected. Crossings are detected using polyline intersections for different chain segments and the height information of the beads in those segments is used to assign top chain segment and bottom chain segment (also used for boosting crossings).\n", + "\n", + "We have set the masks for the crossings as chain weighted gaussians so that the machine learning models can have more information about the crossings and thus have better predictions." + ] + }, + { + "cell_type": "code", + "execution_count": 237, + "id": "cell_code_08", + "metadata": { + "id": "cell_code_08" + }, + "outputs": [], + "source": [ + "def canon_axis(\n", + " u: np.ndarray) -> np.ndarray | None:\n", + " \"\"\"Normalize a 2-D vector and canonicalise its sign.\n", + "\n", + " Ensures that +v and -v are treated as the same axis direction by flipping\n", + " the sign so the first nonzero component is always positive. This makes axis\n", + " comparisons order-independent.\n", + "\n", + " Parameters\n", + " ----------\n", + " u: np.ndarray\n", + " A 2-D vector to normalize\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray | None\n", + " Unit vector with canonicalized sign, or None if u is zero or if input has\n", + " a norm below 1e-12.\n", + "\n", + " Examples\n", + " --------\n", + " >>> u = np.array([1.0, 2.0])\n", + " >>> v = canon_axis(u)\n", + " >>> print(v)\n", + " [0.4472136 0.8944272]\n", + "\n", + " \"\"\"\n", + "\n", + " u = np.asarray(u, dtype=float)\n", + " nrm = float(np.linalg.norm(u))\n", + " if nrm < 1e-12:\n", + " return None\n", + " u = u / nrm\n", + " if (u[0] < 0) or (abs(u[0]) < 1e-12 and u[1] < 0):\n", + " u = -u\n", + " return u\n", + "\n", + "\n", + "def find_polyline_crossings(\n", + " coords_xy: np.ndarray,\n", + " min_separation_beads: int = CROSS_MIN_SEP_BEADS,\n", + " merge_radius_nm: float = 0.5,\n", + ") -> list[dict]:\n", + " \"\"\"Detect all strand crossings of a closed ring polyline in XY.\n", + "\n", + " Performs a brute-force search over all segment pairs, skipping adjacent\n", + " segments, shared-vertex pairs, and pairs whose circular contour separation\n", + " is less than ``minimum_separation_beads``. Raw intersection hits that land\n", + " within ``merge_radius_nm`` of each other are clustered into a single\n", + " crossing, and duplicate chain-axis directions (within ~18°) are\n", + " deduplicated per cluster.\n", + "\n", + " Parameters\n", + " ----------\n", + " coords_xy : np.ndarray\n", + " Array of shape (N,2) containing the [x,y] bead positions in nanometers\n", + " min_separation_beads: int, optional\n", + " Minimum circular contour separation (in beads) required between 2\n", + " segments before their intersection is considered. Defaults to\n", + " CROSS_MIN_SEP_BEADS.\n", + " merge_radius_nm: float, optional\n", + " Maximum distance in nanometers between 2 raw intersections that are\n", + " clustered into a single crossing. Defaults to 0.5 nm.\n", + "\n", + " Returns\n", + " -------\n", + " list[dict]\n", + " Each dict represents one crossing and contains:\n", + " - ``pt_nm`` : np.ndarray, shape (2,) — position in nanometres.\n", + " - ``axes_nm`` : list of np.ndarray — deduplicated unit chain\n", + " direction vectors at the crossing.\n", + " - ``seg_i`` : int — index of the first segment.\n", + " - ``seg_j`` : int — index of the second segment.\n", + " - ``t`` : float — parametric position along segment i.\n", + " - ``u`` : float — parametric position along segment j.\n", + " - ``n_hits`` : int — number of raw hits merged into this cluster.\n", + "\n", + " Examples\n", + " --------\n", + " >>> crossings = find_polyline_crossings(coords[:,:2])\n", + " >>> print(type(crossings))\n", + " \n", + "\n", + " \"\"\"\n", + "\n", + " xy = np.asarray(coords_xy, dtype=float)\n", + " n = int(xy.shape[0])\n", + "\n", + " raw = []\n", + " for i in range(n):\n", + " i2 = (i + 1) % n\n", + " p1, p2 = xy[i], xy[i2]\n", + " for j in range(i + 1, n):\n", + " j2 = (j + 1) % n\n", + " if i == j or i2 == j or j2 == i:\n", + " continue\n", + " if _circ_sep(n, i, j) < int(min_separation_beads):\n", + " continue\n", + " q1, q2 = xy[j], xy[j2]\n", + " hit, pt, t, u = _seg_intersect_2d(p1, p2, q1, q2)\n", + " if not hit:\n", + " continue\n", + " ua = canon_axis(p2 - p1)\n", + " ub = canon_axis(q2 - q1)\n", + " if ua is None or ub is None:\n", + " continue\n", + " raw.append(dict(pt=np.array(pt, float),\n", + " axes=[ua, ub],\n", + " seg_i=int(i), seg_j=int(j),\n", + " t=float(t), u=float(u)))\n", + "\n", + " # Cluster nearby raw intersections\n", + " clusters = []\n", + " for r in raw:\n", + " pt = r[\"pt\"]\n", + " placed = False\n", + " for c in clusters:\n", + " fmc=float(merge_radius_nm)\n", + " if np.linalg.norm(pt - c[\"pt_sum\"] / c[\"n\"]) <= fmc:\n", + " c[\"pt_sum\"] += pt\n", + " c[\"n\"] += 1\n", + " c[\"axes\"].extend(r[\"axes\"])\n", + " c[\"items\"].append(r)\n", + " placed = True\n", + " break\n", + " if not placed:\n", + " clusters.append({\"pt_sum\": pt.copy(), \"n\": 1,\n", + " \"axes\": list(r[\"axes\"]), \"items\": [r]})\n", + "\n", + " out = []\n", + " for c in clusters:\n", + " pt_mean = c[\"pt_sum\"] / c[\"n\"]\n", + " axes = []\n", + " for uvec in c[\"axes\"]:\n", + " uvec = canon_axis(uvec)\n", + " if uvec is None:\n", + " continue\n", + " if any(abs(np.dot(uvec, v)) > 0.95 for v in axes): # ~18°\n", + " continue\n", + " axes.append(uvec)\n", + " rep = c[\"items\"][0]\n", + " out.append(dict(\n", + " pt_nm = np.asarray(pt_mean, dtype=np.float32),\n", + " axes_nm = [np.asarray(v, dtype=np.float32) for v in axes]\n", + " if axes else [np.array([1.0, 0.0], np.float32)],\n", + " seg_i = int(rep[\"seg_i\"]),\n", + " seg_j = int(rep[\"seg_j\"]),\n", + " t = float(rep[\"t\"]),\n", + " u = float(rep[\"u\"]),\n", + " n_hits = int(c[\"n\"]),\n", + " ))\n", + " return out\n", + "\n", + "\n", + "def add_crossing_patch(\n", + " mask: np.ndarray,\n", + " pt_px: tuple[float, float],\n", + " axes_px: list[np.ndarray],\n", + " sigma_center: float = 2.0,\n", + " chain_extent: float = 5.0,\n", + " sigma_perp: float = 1.8,\n", + " center_weight: float = 1.0,\n", + " chain_weight: float = 0.8,\n", + ") -> None:\n", + " \"\"\"Paint one crossing onto a float mask using a chain-weighted Gaussian.\n", + "\n", + " The patch is the sum of two components, composed with np.maximum so that\n", + " multiple crossings accumulate correctly without overwriting:\n", + "\n", + " - An isotropic Gaussian centred on the crossing point, scaled by\n", + " ``center_weight``.\n", + " - The per-axis maximum of anisotropic Gaussians aligned to each chain\n", + " direction (elongated along the chain, narrow across it), scaled by\n", + " ``chain_weight``.\n", + "\n", + " Parameters\n", + " ----------\n", + " mask: np.ndarray\n", + " Float32 array of shape (H,W) to paint onto.\n", + " pt_px: tuple[float, float]\n", + " (x,y) crossing point in pixel coordinates.\n", + " axes_px: list[np.ndarray]\n", + " Unit vectors giving chain directions at the crossing,\n", + " in pixel coordinates\n", + " sigma_center: float, optional\n", + " Parameter for standard deviation in pixels of the\n", + " isotropic center gaussian. Defaults to 2.0.\n", + " chain_extent: float, optional\n", + " Multiplier applied to \"sigma_center\" to set the\n", + " parallel standard deviation of the anisotropic chain gaussians.\n", + " Defaults to 5.0.\n", + " sigma_perp: float, optional\n", + " Parameter for standard deviation in pixels across each chain direction.\n", + " Defaults to 1.8\n", + " center_weight: float, optional\n", + " Amplitude of the isotropic center gaussian. Defaults to 1.0.\n", + " chain_weight: float, optional\n", + " Amplitude of the anisotropic chain gaussians. Defaults to 0.8.\n", + "\n", + " \"\"\"\n", + "\n", + " H, W = mask.shape\n", + " cx, cy = float(pt_px[0]), float(pt_px[1])\n", + " sigma_parallel = max(1e-6, float(chain_extent) * float(sigma_center))\n", + " R = int(np.ceil(3.0 * max(sigma_center, sigma_parallel, sigma_perp)))\n", + " x0 = max(0, int(np.floor(cx - R))); x1 = min(W-1, int(np.ceil(cx + R)))\n", + " y0 = max(0, int(np.floor(cy - R))); y1 = min(H-1, int(np.ceil(cy + R)))\n", + "\n", + " xs = np.arange(x0, x1+1, dtype=float)\n", + " ys = np.arange(y0, y1+1, dtype=float)\n", + " X, Y = np.meshgrid(xs, ys)\n", + " dx = X - cx; dy = Y - cy\n", + "\n", + " gc = np.exp(-0.5 * (dx*dx + dy*dy) / (sigma_center**2))\n", + "\n", + " g_chain = np.zeros_like(gc)\n", + " for v in axes_px:\n", + " vx, vy = float(v[0]), float(v[1])\n", + " u_par = dx*vx + dy*vy\n", + " u_perp = -dx*vy + dy*vx\n", + " g = np.exp(-0.5 * (u_par**2 / sigma_parallel**2\n", + " + u_perp**2 / sigma_perp**2))\n", + " g_chain = np.maximum(g_chain, g)\n", + "\n", + " patch = center_weight * gc + chain_weight * g_chain\n", + " mask[y0:y1+1, x0:x1+1] = np.maximum(mask[y0:y1+1, x0:x1+1], patch)\n", + "\n", + "\n", + "def make_crossing_mask(\n", + " coords: np.ndarray,\n", + " extent: tuple[float, float, float, float],\n", + " nx: int,\n", + " ny: int,\n", + " sigma_center_px: float = CROSS_SIGMA_CENTER_PX,\n", + " sigma_perp_px: float = CROSS_SIGMA_PERP_PX,\n", + " chain_extent: float = CROSS_CHAIN_EXTENT,\n", + " center_weight: float = CROSS_CENTER_WEIGHT,\n", + " chain_weight: float = CROSS_CHAIN_WEIGHT,\n", + " min_separation_beads: int = CROSS_MIN_SEP_BEADS,\n", + " crossings_precomputed: list[dict] | None = None,\n", + " merge_radius_nm: float = 0.5,\n", + ") -> tuple[np.ndarray, list[dict]]:\n", + " \"\"\"Build the crossing ground-truth mask (float32, normalised to [0, 1]).\n", + "\n", + " For each detected (or precomputed) crossing, paints a chain-weighted\n", + " Gaussian blob onto a float32 canvas using ``add_crossing_patch``.The final\n", + " mask is normalised to [0, 1].\n", + "\n", + " Passing ``crossings_precomputed`` is strongly recommended in the dataset\n", + " generation pipeline: reusing the same crossing list that was passed to the\n", + " AFM renderer guarantees that the mask and the image are perfectl\n", + " spatially aligned.\n", + "\n", + " Parameters\n", + " ----------\n", + " coords : np.ndarray\n", + " Array of shape (N,3) or (N,2) containing bead positions in nanometers.\n", + " Only the first two columns (x, y) are used.\n", + " extent: tuple[float, float, float, float]\n", + " The physical bounding box (xmin, xmax, ymin, ymax) in nanometers.\n", + " nx: int\n", + " Number of pixels along the x-axis\n", + " ny: int\n", + " Number of pixels along the y-axis\n", + " sigma_center_px: float, optional\n", + " Parameter for standard deviation in pixels of the\n", + " isotropic center gaussian. Defaults to CROSS_SIGMA_CENTER_PX.\n", + " sigma_perp_px: float, optional\n", + " Parameter for standard deviation in pixels across the\n", + " chain direction at each crossing. Defaults to CROSS_SIGMA_PERP_PX.\n", + " chain_extent: float, optional\n", + " Multiplier on \"sigma_center_px\" that controls how far the\n", + " chain aligned gaussians extend along the strand.\n", + " Defaults to CROSS_CHAIN_EXTENT.\n", + " center_weight: float, optional\n", + " Amplitude of the isotropic center gaussian.\n", + " Defaults to CROSS_CENTER_WEIGHT.\n", + " chain_weight: float, optional\n", + " Amplitude of the anisotropic chain gaussians.\n", + " Defaults to CROSS_CHAIN_WEIGHT.\n", + " min_separation_beads: int, optional\n", + " Minimum circular contour separation (in beads)\n", + " required between 2 segments before their intersection is considered.\n", + " Defaults to CROSS_MIN_SEP_BEADS.\n", + " crossings_precomputed: list[dict] | None, optional\n", + " precomputed crossing list from \"find_polyline_crossings\"\n", + " or the AFM renderer. If None, crossings are detected automatically.\n", + " Defaults to None.\n", + " merge_radius_nm: float, optional\n", + " Maximum distance in nanometers between 2 raw\n", + " intersections that are clustered into a single crossing.\n", + " Defaults to 0.5 nm.\n", + "\n", + " Returns\n", + " -------\n", + " crossing_mask: np.ndarray\n", + " Float32 array of shape (ny, nx) with values in [0, 1].\n", + " crossings: list[dict]\n", + " Each dict represents one crossing\n", + "\n", + " Examples\n", + " --------\n", + " >>> crossing_mask, crossings = make_crossing_mask(coords,\n", + " extent, nx=512, ny=512, crossings_precomputed=precomputed_crossings)\n", + " >>> print(crossing_mask.shape, len(crossings))\n", + " (512, 512) 4\n", + "\n", + " \"\"\"\n", + "\n", + " coords = np.asarray(coords, dtype=np.float32)\n", + " xy_nm = coords[:, :2].astype(float)\n", + "\n", + " if crossings_precomputed is None:\n", + " crossings = find_polyline_crossings(\n", + " xy_nm,\n", + " min_separation_beads=min_separation_beads,\n", + " merge_radius_nm=float(merge_radius_nm),\n", + " )\n", + " else:\n", + " crossings = crossings_precomputed\n", + "\n", + " xmin, xmax, ymin, ymax = extent\n", + " sx = (nx - 1) / (xmax - xmin)\n", + " sy = (ny - 1) / (ymax - ymin)\n", + "\n", + " mask = np.zeros((ny, nx), dtype=np.float32)\n", + "\n", + " for c in crossings:\n", + " x_nm, y_nm = c[\"pt_nm\"]\n", + " px = (x_nm - xmin) * sx\n", + " py = (y_nm - ymin) * sy\n", + "\n", + " axes_px = []\n", + " for v in c[\"axes_nm\"]:\n", + " vx_px = v[0] * sx; vy_px = v[1] * sy\n", + " nrm = float(np.hypot(vx_px, vy_px))\n", + " if nrm < 1e-12:\n", + " continue\n", + " axes_px.append(np.array([vx_px/nrm, vy_px/nrm], dtype=float))\n", + " if not axes_px:\n", + " axes_px = [np.array([1.0, 0.0], dtype=float)]\n", + "\n", + " add_crossing_patch(\n", + " mask,\n", + " pt_px=(px, py),\n", + " axes_px=axes_px,\n", + " sigma_center=float(sigma_center_px),\n", + " chain_extent=float(chain_extent),\n", + " sigma_perp=float(sigma_perp_px),\n", + " center_weight=float(center_weight),\n", + " chain_weight=float(chain_weight),\n", + " )\n", + "\n", + " m = float(mask.max())\n", + " if m > 1e-12:\n", + " mask /= m\n", + " return mask.astype(np.float32), crossings" + ] + }, + { + "cell_type": "markdown", + "id": "cell_md_09", + "metadata": { + "id": "cell_md_09" + }, + "source": [ + "## 10. Decoy Chain Functions\n", + "\n", + "real AFM images often contain small chain segments that are not part of the main chain and thus constitute the noise in that sample, but since those segments are broken off DNA, they cannot be neatly integrated into the noise model.\n", + "Therefore, we offer the possibility of addition of small DNA chains to every every sample in the dataset where ``add_decoy = True`` which would then contain a small 2–4 bead \"decoy\" fragment placed in a corner of the image.\n", + "\n", + "The decoy appears in the AFM image but is **excluded** from both\n", + "ground-truth masks, training the model to ignore isolated unconnected fragments." + ] + }, + { + "cell_type": "code", + "execution_count": 238, + "id": "cell_code_09", + "metadata": { + "id": "cell_code_09" + }, + "outputs": [], + "source": [ + "def make_decoy_chain(\n", + " seed: int,\n", + " n_beads_range: tuple[int, int] = (2, 4),\n", + " bond_length: float = BOND_LENGTH,\n", + ") -> np.ndarray:\n", + " \"\"\"Generate a small (2–4 bead) slightly curved chain without MD relaxation.\n", + "\n", + " This function is used to generate a small decoy chain segment with the\n", + " number of beads given by ``n_beads_range``.\n", + "\n", + " Parameters\n", + " ----------\n", + " seed: int\n", + " Random seed for number of beads within range, ``n_beads_range``.\n", + " n_beads_range: tuple[int, int], optional\n", + " Range of number of beads to generate the decoy. Defaults to (2,4)\n", + " bond_length: float, optional\n", + " Bond length in nanometers. Defaults to BOND_LENGTH.\n", + "\n", + " Returns\n", + " -------\n", + " coords: np.ndarray\n", + " Array of shape (N,3) containing bead positions in nanometers.\n", + "\n", + " Examples\n", + " --------\n", + " >>> coords = make_decoy_chain(seed=42)\n", + " >>> print(coords.shape)\n", + " (3, 3)\n", + "\n", + " \"\"\"\n", + "\n", + " rng = np.random.default_rng(int(seed))\n", + " n_b = rng.integers(n_beads_range[0], n_beads_range[1] + 1)\n", + " coords = np.zeros((n_b, 3), dtype=np.float32)\n", + " angle = rng.uniform(0, 2 * np.pi)\n", + " dirn = np.array([np.cos(angle), np.sin(angle), 0.0], dtype=np.float32)\n", + "\n", + " for i in range(1, n_b):\n", + " da = rng.normal(0, 0.3)\n", + " c, s = np.cos(da), np.sin(da)\n", + " R = np.array([[c, -s, 0], [s, c, 0], [0, 0, 1]], dtype=np.float32)\n", + " dirn = R @ dirn\n", + " dirn = dirn / np.linalg.norm(dirn)\n", + " coords[i] = coords[i-1] + bond_length * dirn\n", + "\n", + " coords[:, 2] = rng.uniform(2.5, 4.0, n_b)\n", + " return coords\n", + "\n", + "\n", + "def place_decoy_in_corner(\n", + " decoy_coords: np.ndarray,\n", + " global_extent: tuple[float, float, float, float],\n", + " corner_margin_nm: float = 2.0,\n", + " seed: int | None = None,\n", + ") -> np.ndarray:\n", + " \"\"\"Translate decoy_coords so its centroid lands in a random corner.\n", + "\n", + " This function takes the coordinates of the decoy and places it at a\n", + " distance of corner_margin_nm away from one of the corners of the image.\n", + "\n", + " Parameters\n", + " ----------\n", + " decoy_coords: np.ndarray\n", + " Array of shape (N,3) containing bead positions in nanometers.\n", + " global_extent: tuple[float float float float]\n", + " The physical bounding box (xmin, xmax, ymin, ymax) in nanometers.\n", + " corner_margin_nm: float, optional\n", + " Distance in nanometers to place the decoy inside the frame.\n", + " Defaults to 2.0.\n", + " seed: int | None, optional\n", + " Random seed for corner selection. Defaults to None.\n", + "\n", + " Returns\n", + " -------\n", + " decoy_coords: np.ndarray\n", + "\n", + " Examples\n", + " --------\n", + " >>> decoy_coords = place_decoy_in_corner(decoy_coords, global_extent)\n", + " >>> print(decoy_coords.shape)\n", + " (3, 3)\n", + "\n", + " \"\"\"\n", + "\n", + " if seed is None:\n", + " seed = int(np.sum(decoy_coords))\n", + " rng = np.random.default_rng(int(seed))\n", + " xmin, xmax, ymin, ymax = global_extent\n", + " corner = rng.integers(0, 4)\n", + " targets = [\n", + " (xmin + corner_margin_nm, ymax - corner_margin_nm), # top-left\n", + " (xmax - corner_margin_nm, ymax - corner_margin_nm), # top-right\n", + " (xmin + corner_margin_nm, ymin + corner_margin_nm), # bottom-left\n", + " (xmax - corner_margin_nm, ymin + corner_margin_nm), # bottom-right\n", + " ]\n", + " tx, ty = targets[corner]\n", + " centroid = decoy_coords.mean(axis=0)\n", + " offset = np.array([tx, ty, 0.0]) - centroid\n", + " return decoy_coords + offset" + ] + }, + { + "cell_type": "markdown", + "id": "cell_md_10", + "metadata": { + "id": "cell_md_10" + }, + "source": [ + "## 11. Chain Generation Pipeline\n", + "\n", + "Now, we are finally ready to generate on sample in our dataset. The following functions are used for building the final image and masks:\n", + "- `generate_chain_with_beads` with `n_beads` defaulting to `N_BEADS`\n", + "- `generate_one_sample_multilength` generates the image and mask (this is what iterates to produce the dataset)\n", + "- `random_transform_noise_texture` applies a per-sample random affine transform to the noise texture for variety (in case of blank .spm files)\n", + "- Noise injection uses `blank.spm` when available and the PSD model fallback otherwise\n" + ] + }, + { + "cell_type": "code", + "execution_count": 239, + "id": "cell_code_10", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cell_code_10", + "outputId": "b8656359-509b-49c6-e046-61abba117519" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chosen block: 'Z offset: V [Sens. DeformationSens] (0.00000000093132 V/LSB) 0.01733094 V' 512x512 bpp=4 decode= dict[str, Any]:\n", + " \"\"\"Build a tangled ring with n_beads and run MD relaxation if needed.\n", + "\n", + " This function creates an initial ring polymer with a specified number of\n", + " beads, optionally relaxes it using molecular dynamics, and extracts the\n", + " final bead coordinates. Self-crossings are then detected from the final\n", + " 2D projection of the chain.\n", + " Optionally, a decoy chain fragment can also be generated and placed near\n", + " one corner of the main chain bounding box.\n", + "\n", + " Parameters\n", + " ----------\n", + " seed: int\n", + " Random seed for initial ring creation.\n", + " n_beads: int\n", + " Number of beads in the initial ring. Defaults to N_BEADS.\n", + " add_decoy: bool\n", + " Whether to add a corner-placed decoy fragment. Defaults to False.\n", + "\n", + " Returns\n", + " -------\n", + " A dict containing the following keys:\n", + " - ``\"seed\"`` : int\n", + " The normalized integer seed.\n", + " - ``\"n_beads\"`` : int\n", + " Number of beads in the generated chain.\n", + " - ``\"coords\"`` : np.ndarray\n", + " Final bead coordinates with shape ``(N, 3)`` and dtype\n", + " ``np.float32``.\n", + " - ``\"crossings\"`` : list\n", + " Detected self-crossings in the 2D projected chain.\n", + " - ``\"decoy_coords\"`` : np.ndarray or None\n", + " Coordinates of the optional decoy fragment, or ``None`` if no\n", + " decoy was added.\n", + "\n", + " Examples\n", + " --------\n", + " >>> chain = generate_chain_with_beads(seed=42, n_beads=10)\n", + " >>> chain[\"seed\"]\n", + " 42\n", + " >>> chain[\"n_beads\"]\n", + " 10\n", + " >>> chain[\"coords\"].shape\n", + " (10, 3)\n", + "\n", + " \"\"\"\n", + "\n", + " seed = int(seed)\n", + " n_beads = int(n_beads)\n", + "\n", + " if USE_MD:\n", + " coords0 = make_tangled_ring_initial(\n", + " seed,\n", + " n_beads=n_beads,\n", + " bond_length=BOND_LENGTH,\n", + " persistence_bonds=PERSISTENCE_BONDS,\n", + " base_z=BASE_Z,\n", + " )\n", + " frames = run_md_relaxation(coords0, seed=seed,\n", + " n_frames=N_FRAMES,\n", + " steps_per_frame=STEPS_PER_FRAME)\n", + " else:\n", + " frames = make_ring_2d_persistent_initial(\n", + " seed,\n", + " n_beads=n_beads,\n", + " bond_length=BOND_LENGTH,\n", + " persistence_bonds=PERSISTENCE_BONDS,\n", + " angle_stiffness_mult=ANGLE_STIFNESS_MULT,\n", + " )\n", + "\n", + " last_coords = frames[-1].astype(np.float32)\n", + "\n", + " crossings = find_polyline_crossings(\n", + " last_coords[:, :2],\n", + " min_separation_beads=CROSS_MIN_SEP_BEADS,\n", + " merge_radius_nm=0.5,\n", + " )\n", + "\n", + " decoy_coords = None\n", + " if add_decoy:\n", + " xmin, xmax = last_coords[:, 0].min(), last_coords[:, 0].max()\n", + " ymin, ymax = last_coords[:, 1].min(), last_coords[:, 1].max()\n", + " decoy_raw = make_decoy_chain(seed + 9999)\n", + " decoy_coords = place_decoy_in_corner(\n", + " decoy_raw, (xmin, xmax, ymin, ymax),\n", + " corner_margin_nm=15.0, seed=seed)\n", + "\n", + " return dict(seed=seed, n_beads=n_beads,\n", + " coords=last_coords, crossings=crossings,\n", + " decoy_coords=decoy_coords)\n", + "\n", + "\n", + "def render_chain_and_masks(\n", + " chain: dict,\n", + " noise_source: str = \"none\",\n", + " noise_asset: dict | np.ndarray | None = None,\n", + ") -> dict[str, Any]:\n", + " \"\"\"Render AFM image + DNA mask + crossing mask for a chain dict.\n", + "\n", + " This function renders a high-resolution AFM image from a chain sample,\n", + " optionally composites a decoy fragment into the image, adds background\n", + " noise, and generates corresponding DNA and crossing masks.\n", + " The AFM image is first rendered on an internal physical grid determined\n", + " from the chain extent and the target pixel size. The image and masks are\n", + " then resized to the final network resolution.\n", + " Decoy fragments, when present, are composited into the AFM image using\n", + " maximum-intensity blending, but are deliberately excluded from both the\n", + " DNA mask and crossing mask.\n", + "\n", + " Parameters\n", + " ----------\n", + " chain: dict\n", + " A dict containing the following keys:\n", + " -``\"seed\"``\n", + " -``\"coords\"``\n", + " -``\"crossings\"``.\n", + " The optional key\n", + " ``\"decoy_coords\"`` may also be present\n", + " noise_source: str\n", + " Noise generation source passed to `sample_noise_image`.\n", + " noise_asset: dict | np.ndarray | None\n", + " Noise asset passed to `sample_noise_image`\n", + "\n", + " Returns\n", + " -------\n", + " A dict containing the following keys:\n", + " - ``\"seed\"`` : int\n", + " Random seed associated with the sample.\n", + " - ``\"afm_img\"`` : np.ndarray\n", + " Final AFM image with shape ``(NY, NX)`` and dtype\n", + " ``np.float32``.\n", + " - ``\"dna_mask\"`` : np.ndarray\n", + " Final binary DNA mask with shape ``(NY, NX)`` and dtype\n", + " ``np.uint8``.\n", + " - ``\"cross_mask\"`` : np.ndarray\n", + " Final crossing mask with shape ``(NY, NX)`` and dtype\n", + " ``np.float32``.\n", + " - ``\"extent\"`` : np.ndarray\n", + " Physical image extent as ``(xmin, xmax, ymin, ymax)`` with dtype\n", + " ``np.float32``.\n", + " - ``\"n_crossings\"`` : int\n", + " Number of crossing regions included in the crossing mask.\n", + " - ``\"decoy_coords\"`` : np.ndarray or None\n", + " Final decoy coordinates, or ``None`` if no decoy was used.\n", + "\n", + " Examples\n", + " --------\n", + " >>> sample = generate_chain_with_beads(seed=1)\n", + " >>> rendered = render_chain_and_masks(sample)\n", + " >>> rendered[\"afm_img\"].shape\n", + " (NY, NX)\n", + " >>> rendered[\"dna_mask\"].dtype\n", + " dtype('uint8')\n", + "\n", + " \"\"\"\n", + "\n", + " seed = int(chain[\"seed\"])\n", + " coords = chain[\"coords\"]\n", + " crossings = chain[\"crossings\"]\n", + " decoy_coords = chain.get(\"decoy_coords\", None)\n", + "\n", + " padding = 10.0\n", + " xmin = coords[:, 0].min() - padding\n", + " xmax = coords[:, 0].max() + padding\n", + " ymin = coords[:, 1].min() - padding\n", + " ymax = coords[:, 1].max() + padding\n", + " global_extent = (xmin, xmax, ymin, ymax)\n", + "\n", + " # internal render grid is determined from extent and nm_per_px\n", + " nx_phys, ny_phys, _ = compute_internal_render_grid(\n", + " global_extent, AFM_KW[\"target_nm_per_px\"]\n", + " )\n", + " afm_kw_phys = {**AFM_KW, \"nx\": nx_phys, \"ny\": ny_phys}\n", + "\n", + " afm_img_hr, dbg = create_z_based_afm(\n", + " coords, grain_seed=seed,\n", + " crossings_precomputed=crossings,\n", + " extent=global_extent,\n", + " **afm_kw_phys\n", + " )\n", + "\n", + " if decoy_coords is not None:\n", + " decoy_coords = place_decoy_in_corner(\n", + " decoy_coords, global_extent,\n", + " corner_margin_nm=8.0, seed=seed)\n", + " decoy_kw = {**afm_kw_phys,\n", + " \"apply_edge_taper\": False,\n", + " \"enable_crossing_boost\": False,\n", + " \"add_center_ridge\": False}\n", + " decoy_afm_hr, _ = create_z_based_afm(\n", + " decoy_coords, extent=global_extent, **decoy_kw)\n", + " afm_img_hr = np.maximum(afm_img_hr, decoy_afm_hr)\n", + "\n", + " actual_extent = dbg[\"extent\"]\n", + "\n", + " noise_img = sample_noise_image(\n", + " noise_source=noise_source,\n", + " noise_asset=noise_asset,\n", + " seed=seed,\n", + " out_shape=afm_img_hr.shape,\n", + " target_rms_nm=TARGET_NOISE_RMS_NM,\n", + " )\n", + " if noise_img is not None:\n", + " if noise_img is not None:\n", + " afm_img_hr = afm_img_hr + noise_img.astype(np.float32)\n", + " \n", + " # Keep high values bounded, but preserve negative background noise.\n", + " afm_img_hr = np.minimum(\n", + " afm_img_hr,\n", + " AFM_KW[\"max_height_nm\"],\n", + " ).astype(np.float32)\n", + "\n", + " dna_mask_hr = make_dna_mask_from_beads(\n", + " coords, actual_extent, nx_phys, ny_phys, dilate_px=DNA_MASK_DILATE_PX)\n", + "\n", + " cross_mask_hr, crossings_out = make_crossing_mask(\n", + " coords, actual_extent, nx_phys, ny_phys,\n", + " sigma_center_px=CROSS_SIGMA_CENTER_PX,\n", + " sigma_perp_px=CROSS_SIGMA_PERP_PX,\n", + " chain_extent=CROSS_CHAIN_EXTENT,\n", + " center_weight=CROSS_CENTER_WEIGHT,\n", + " chain_weight=CROSS_CHAIN_WEIGHT,\n", + " min_separation_beads=CROSS_MIN_SEP_BEADS,\n", + " crossings_precomputed=crossings,\n", + " merge_radius_nm=0.5,\n", + " )\n", + "\n", + " if CROSS_CLIP_TO_DNA_MASK:\n", + " cross_mask_hr = cross_mask_hr * dna_mask_hr.astype(np.float32)\n", + "\n", + " #Logic for maintaining user defined resolution\n", + " afm_img = resize_image_to_shape(afm_img_hr.astype(np.float32),\n", + " (NY, NX), order=1).astype(np.float32)\n", + " dna_mask = (resize_image_to_shape(dna_mask_hr.astype(np.float32),\n", + " (NY, NX), order=0)>0.5).astype(np.uint8)\n", + " cross_mask = resize_image_to_shape(cross_mask_hr.astype(np.float32),\n", + " (NY, NX), order=1).astype(np.float32)\n", + "\n", + " return dict(\n", + " seed=seed,\n", + " afm_img=afm_img.astype(np.float32),\n", + " dna_mask=dna_mask.astype(np.uint8),\n", + " cross_mask=cross_mask.astype(np.float32),\n", + " extent=np.array(actual_extent, dtype=np.float32),\n", + " n_crossings=int(len(crossings_out)),\n", + " decoy_coords=decoy_coords,\n", + " )\n", + "\n", + "\n", + "def generate_one_sample_multilength(\n", + " seed: int,\n", + " n_beads: int,\n", + " noise_source: str = \"none\",\n", + " noise_asset: dict | np.ndarray | None = None,\n", + " add_decoy: bool = False,\n", + ") -> dict[str, Any]:\n", + " \"\"\"Generate one complete sample at a specified bead count.\n", + "\n", + " This function generates a single chain realization with the requested\n", + " number of beads, renders the corresponding AFM image and supervision masks,\n", + " and appends the bead count to the returned sample dictionary.\n", + "\n", + " Noise can optionally be injected during rendering using either a blank\n", + " SPM-derived texture or a PSD-based synthetic noise model, depending on\n", + " the provided noise configuration.\n", + "\n", + " Parameters\n", + " ----------\n", + " seed: int\n", + " Random seed for initial ring creation.\n", + " n_beads: int\n", + " Number of beads in the initial ring.\n", + " noise_source: str, optional\n", + " Noise generation source passed to `render_chain_and_masks`.\n", + " Defaults to \"none\".\n", + " noise_asset: dict | np.ndarray | None, optional\n", + " Noise asset passed to `render_chain_and_masks`. Defaults to `None`.\n", + " add_decoy: bool, optional\n", + " Whether to add a corner-placed decoy fragment. Defaults to `False`.\n", + "\n", + " Returns\n", + " -------\n", + " dict[str, Any]\n", + " Dictionary containing the rendered sample, including AFM image,\n", + " DNA mask, crossing mask, physical extent, crossing count, optional\n", + " decoy coordinates, and the bead count under ``\"n_beads\"``.\n", + "\n", + " Notes\n", + " -----\n", + " This function prints which noise model is being used for the noise\n", + " injection and if no noise model has been provided then\n", + " it prints a statement that reflects that noise injection has been disabled.\n", + "\n", + " Examples\n", + " --------\n", + " >>> sample = generate_one_sample_multilength(seed=1, n_beads=300)\n", + " >>> sample[\"n_beads\"]\n", + " 300\n", + "\n", + " >>> sample[\"afm_img\"].shape\n", + " (NY, NX)\n", + "\n", + " \"\"\"\n", + "\n", + " chain = generate_chain_with_beads(seed, n_beads, add_decoy=add_decoy)\n", + "\n", + " s = render_chain_and_masks(\n", + " chain,\n", + " noise_source=noise_source,\n", + " noise_asset=noise_asset,\n", + " )\n", + " s[\"n_beads\"] = int(n_beads)\n", + " return s\n", + "\n", + "\n", + "# ── Load noise asset once; prefer blank.spm, fall back to PSD model ──────────\n", + "noise_source = \"none\"\n", + "noise_asset = None\n", + "noise_diag = {\"source\": \"none\"}\n", + "\n", + "if USE_BLANK_SPM_NOISE:\n", + " blank_path = str(BLANK_SPM_PATH) if BLANK_SPM_PATH else \"\"\n", + " if blank_path and os.path.isfile(blank_path):\n", + " try:\n", + " noise_rms_nm, noise_asset, noise_diag = load_blank_spm_noise(\n", + " blank_path,\n", + " target_rms_nm=TARGET_NOISE_RMS_NM,\n", + " verbose=True,\n", + " )\n", + " noise_source = \"blank_spm\"\n", + " print(f\"Loaded blank .spm noise texture\"\n", + " f\" RMS ≈ {noise_rms_nm:.3f} nm\")\n", + " except Exception as e:\n", + " print(\"blank .spm noise failed; trying PSD fallback. Error:\", e)\n", + " else:\n", + " print(\"No blank .spm file found; trying PSD fallback noise model.\")\n", + "\n", + "if noise_source == \"none\" and USE_PSD_NOISE_FALLBACK:\n", + " try:\n", + " noise_asset = load_model(MODEL_PATH)\n", + " noise_source = \"psd_model\"\n", + " noise_diag = {\n", + " \"source\": \"psd_model\",\n", + " \"model_path\": str(MODEL_PATH),\n", + " \"method\": PSD_NOISE_METHOD,\n", + " \"target_rms_nm\": float(TARGET_NOISE_RMS_NM),\n", + " }\n", + " print(f\"Loaded PSD fallback noise model from: {MODEL_PATH}\")\n", + " except Exception as e:\n", + " print(\"PSD fallback noise model failed;\"\n", + " \"proceeding without noise. Error:\", e)\n", + " noise_asset = None\n", + "\n", + "if noise_source == \"none\":\n", + " print(\"Noise injection disabled.\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "cell_md_11", + "metadata": { + "id": "cell_md_11" + }, + "source": [ + "## 12. Sanity Check\n", + "\n", + "It is always a good idea to check if the pipeline is working correctly and producing the inteded resutls and so we have added a sanity check that can be performed before starting the generation of the entire dataset.\n", + "Here we render one sample per bead count for the bead counts provided in the global variables and by default we have set `add_decoy=True` here.\n", + "\n", + "This check displays the AFM image, DNA mask, and crossing mask side-by-side.\n", + "We also print the extent / decoy-placement diagnostics for verification and adjustment." + ] + }, + { + "cell_type": "code", + "execution_count": 240, + "id": "cell_code_11", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "cell_code_11", + "outputId": "f6277616-5d72-491c-ed9e-12b8268f0b7e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "\n", + "==================== SAMPLE 1 (Seed: 1, 70 beads) ====================\n", + "Image window (nm): X=[-16.7, 16.5], Y=[-16.4, 16.1]\n", + "Decoy XY bounds (nm): X=[8.2, 8.8], Y=[7.7, 8.5]\n", + "Decoy Z range (nm): -0.03 – 0.03\n", + "Decoy inside extent.\n", + " Decoy height ≈ 0\n", + "\n", + "==================== SAMPLE 2 (Seed: 2, 80 beads) ====================\n", + "Image window (nm): X=[-20.8, 19.6], Y=[-20.7, 20.9]\n", + "Decoy XY bounds (nm): X=[11.4, 11.9], Y=[-13.7, -11.7]\n", + "Decoy Z range (nm): -0.26 – 0.15\n", + "Decoy inside extent.\n", + "\n", + "==================== SAMPLE 3 (Seed: 3, 90 beads) ====================\n", + "Image window (nm): X=[-27.8, 25.9], Y=[-14.3, 14.1]\n", + "Decoy XY bounds (nm): X=[17.6, 18.2], Y=[-7.8, -4.9]\n", + "Decoy Z range (nm): -0.39 – 0.44\n", + "Decoy inside extent.\n", + "\n", + "==================== SAMPLE 4 (Seed: 4, 100 beads) ====================\n", + "Image window (nm): X=[-20.9, 20.9], Y=[-24.3, 21.5]\n", + "Decoy XY bounds (nm): X=[-13.0, -12.7], Y=[-16.8, -15.8]\n", + "Decoy Z range (nm): -0.24 – 0.24\n", + "Decoy inside extent.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bead_counts = list(BEAD_COUNTS)\n", + "seeds = [int(BASE_SEED + k) for k in range(len(bead_counts))]\n", + "\n", + "samples = [\n", + " generate_one_sample_multilength(\n", + " seeds[i], n_beads=bead_counts[i],\n", + " noise_source=noise_source, noise_asset=noise_asset, add_decoy=True\n", + " )\n", + " for i in range(len(bead_counts))\n", + "]\n", + "#---------Plotting-------------------------------------------------------------\n", + "\n", + "fig, axes = plt.subplots(len(samples), 3, figsize=(16, 5 * len(samples)))\n", + "\n", + "for r, s in enumerate(samples):\n", + " extent = s[\"extent\"]\n", + " img = s[\"afm_img\"]\n", + "\n", + " print(f\"\\n{'='*20} SAMPLE {r+1} (Seed: {s['seed']}, \"\n", + " f\"{s['n_beads']} beads) {'='*20}\")\n", + " print(f\"Image window (nm): X=[{extent[0]:.1f}, {extent[1]:.1f}], \"\n", + " f\"Y=[{extent[2]:.1f}, {extent[3]:.1f}]\")\n", + "\n", + " if s.get(\"decoy_coords\") is not None:\n", + " d = s[\"decoy_coords\"]\n", + " print(f\"Decoy XY bounds (nm): \"\n", + " f\"X=[{d[:,0].min():.1f}, {d[:,0].max():.1f}], \"\n", + " f\"Y=[{d[:,1].min():.1f}, {d[:,1].max():.1f}]\")\n", + " print(f\"Decoy Z range (nm): {d[:,2].min():.2f} – {d[:,2].max():.2f}\")\n", + " oob = (d[:,0].min() < extent[0] or d[:,0].max() > extent[1] or\n", + " d[:,1].min() < extent[2] or d[:,1].max() > extent[3])\n", + " print(\" Decoy out-of-bounds!\" if oob else \"Decoy inside extent.\")\n", + " if d[:,2].max() < 0.1:\n", + " print(\" Decoy height ≈ 0\")\n", + "\n", + " ax1, ax2, ax3 = axes[r]\n", + " ext_list = list(extent)\n", + "\n", + " ax1.imshow(img, cmap=\"afmhot\", origin=\"lower\", extent=ext_list)\n", + " ax1.set_title(f\"AFM image\\n(seed {s['seed']}, {s['n_beads']} beads)\")\n", + " ax1.axis(\"off\")\n", + "\n", + " ax2.imshow(s[\"dna_mask\"], cmap=\"gray\", origin=\"lower\", extent=ext_list)\n", + " ax2.set_title(\"DNA mask (decoy excluded)\")\n", + " ax2.axis(\"off\")\n", + "\n", + " ax3.imshow(s[\"cross_mask\"], cmap=\"magma\", origin=\"lower\", extent=ext_list)\n", + " ax3.set_title(f\"Crossing mask (n={s['n_crossings']})\")\n", + " ax3.axis(\"off\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "3YoKkN3e5dIo", + "metadata": { + "id": "3YoKkN3e5dIo" + }, + "source": [ + "## 13. Benchmarking\n", + "\n", + "We also provide the option to benchmark the performance of the pipeline and to see estimates on how long it might take to generate the required amount of samples. This can be very useful to compare which system might be optimal for production of the dataset and how GPU acceleration can be used to improve the time needed for dataset generation." + ] + }, + { + "cell_type": "code", + "execution_count": 241, + "id": "WLAYkyIQlhuX", + "metadata": { + "id": "WLAYkyIQlhuX" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==============================================================\n", + " SYSTEM PROFILE\n", + "==============================================================\n", + " OS : Linux 4.18.0-553.123.1.el8_10.x86_64\n", + " CPU (logical) : 64 cores\n", + " RAM available : 513.4 GB\n", + " OpenMM Platforms: ['Reference', 'CPU', 'CUDA']\n", + " Active Platform : CUDA\n", + " Mode : MD (OpenMM)\n", + "\n", + "==============================================================\n", + " RUNNING BENCHMARK\n", + "==============================================================\n", + "Using CUDA platform.\n", + " Rep 1/3: 2.76s\n", + "Using CUDA platform.\n", + " Rep 2/3: 2.65s\n", + "Using CUDA platform.\n", + " Rep 3/3: 2.72s\n", + "==============================================================\n", + " Median Wall Time: 2.72 s\n", + " Mean Wall Time : 2.71 s\n", + " Peak RAM (RSS) : 3662.2 MB\n", + " Projected Total : 3.0 hours for 4000 samples\n", + "==============================================================\n" + ] + } + ], + "source": [ + "import time\n", + "import tracemalloc\n", + "import os\n", + "import platform\n", + "import psutil\n", + "import threading\n", + "import statistics\n", + "\n", + "class _PeakMemTracker:\n", + " \"\"\"Track peak resident memory usage in a background thread.\n", + "\n", + " This helper periodically samples the current process RSS and stores the\n", + " largest value observed during the tracked interval.\n", + "\n", + " Attributes\n", + " ----------\n", + " peak_mb : float\n", + " Peak resident set size observed during tracking, in megabytes.\n", + " \"\"\"\n", + "\n", + " def __init__(self, poll_interval_s: float = 0.05) -> None:\n", + " \"\"\"Initialize the memory tracker.\n", + "\n", + " Parameters\n", + " ----------\n", + " poll_interval_s : float, optional\n", + " Sampling interval in seconds, by default ``0.05``.\n", + " \"\"\"\n", + " self._process = psutil.Process(os.getpid())\n", + " self._poll_interval_s = float(poll_interval_s)\n", + " self._stop_event = threading.Event()\n", + " self._thread: threading.Thread | None = None\n", + " self.peak_mb = 0.0\n", + "\n", + " def _run(self) -> None:\n", + " \"\"\"Continuously sample RSS until tracking is stopped.\"\"\"\n", + " while not self._stop_event.is_set():\n", + " try:\n", + " rss_mb = self._process.memory_info().rss / 1e6\n", + " if rss_mb > self.peak_mb:\n", + " self.peak_mb = rss_mb\n", + " except Exception:\n", + " pass\n", + "\n", + " self._stop_event.wait(self._poll_interval_s)\n", + "\n", + " def start(self) -> None:\n", + " \"\"\"Start background memory tracking.\"\"\"\n", + " self._stop_event.clear()\n", + " self._thread = threading.Thread(target=self._run, daemon=True)\n", + " self._thread.start()\n", + "\n", + " def stop(self) -> None:\n", + " \"\"\"Stop background memory tracking.\"\"\"\n", + " self._stop_event.set()\n", + " if self._thread is not None:\n", + " self._thread.join()\n", + "\n", + "\n", + "def _bench_stages(\n", + " seed: int,\n", + " n_beads: int\n", + ") -> dict[str, float]:\n", + " \"\"\"Benchmark the major stages of one sample-generation pipeline run.\n", + "\n", + " Parameters\n", + " ----------\n", + " seed : int\n", + " Random seed for the benchmarked sample.\n", + " n_beads : int\n", + " Number of beads in the benchmarked chain.\n", + "\n", + " Returns\n", + " -------\n", + " dict[str, float]\n", + " Stage timings in seconds. Keys are:\n", + " ``\"1_chain_init\"``, ``\"2_md_relax\"``, ``\"3_crossing_detect\"``,\n", + " and ``\"4_afm_render_masks\"``.\n", + "\n", + " \"\"\"\n", + "\n", + " seed = int(seed)\n", + " n_beads = int(n_beads)\n", + "\n", + " timings: dict[str, float] = {}\n", + " t0 = time.perf_counter()\n", + "\n", + " if USE_MD:\n", + " coords0 = make_tangled_ring_initial(seed, n_beads=n_beads)\n", + " timings[\"1_chain_init\"] = time.perf_counter() - t0\n", + "\n", + " t0 = time.perf_counter()\n", + " frames = run_md_relaxation(\n", + " coords0,\n", + " seed=seed,\n", + " n_frames=N_FRAMES,\n", + " steps_per_frame=STEPS_PER_FRAME,\n", + " )\n", + " timings[\"2_md_relax\"] = time.perf_counter() - t0\n", + " else:\n", + " timings[\"1_chain_init\"] = 0.0\n", + "\n", + " t0 = time.perf_counter()\n", + " frames = make_ring_2d_persistent_initial(seed, n_beads=n_beads)\n", + " timings[\"2_md_relax\"] = time.perf_counter() - t0\n", + "\n", + " last_coords = frames[-1]\n", + "\n", + " t0 = time.perf_counter()\n", + " crossings = find_polyline_crossings(last_coords[:, :2])\n", + " timings[\"3_crossing_detect\"] = time.perf_counter() - t0\n", + "\n", + " t0 = time.perf_counter()\n", + " chain = {\n", + " \"seed\": seed,\n", + " \"n_beads\": n_beads,\n", + " \"coords\": last_coords,\n", + " \"crossings\": crossings,\n", + " }\n", + " render_chain_and_masks(\n", + " chain,\n", + " noise_source=\"none\",\n", + " noise_asset=None,\n", + " )\n", + " timings[\"4_afm_render_masks\"] = time.perf_counter() - t0\n", + "\n", + " return timings\n", + "\n", + "\n", + "def benchmark_pipeline(\n", + " seed: int,\n", + " n_beads: int,\n", + " n_reps: int = 3,\n", + " total_samples: int | None = None,\n", + " print_report: bool = True,\n", + ") -> dict[str, Any]:\n", + " \"\"\"Benchmark the sample-generation pipeline and report timing statistics.\n", + "\n", + " This function prints a system profile, runs repeated benchmark passes for\n", + " one representative sample configuration, tracks peak RSS memory usage, and\n", + " estimates the total runtime for the full dataset.\n", + "\n", + " Parameters\n", + " ----------\n", + " seed : int\n", + " Base random seed for the benchmark runs.\n", + " n_beads : int\n", + " Number of beads used in each benchmarked sample.\n", + " n_reps : int, optional\n", + " Number of benchmark repetitions, by default ``3``.\n", + " total_samples : int or None, optional\n", + " Total number of samples to use when projecting full runtime. If\n", + " ``None``, the projection is omitted.\n", + " print_report : bool, optional\n", + " Whether to print the system and benchmark summary, by default ``True``.\n", + "\n", + " Returns\n", + " -------\n", + " dict[str, Any]\n", + " Dictionary containing benchmark results, including wall times, stage\n", + " timings, median runtime, peak RSS memory, and projected total runtime.\n", + "\n", + " Notes\n", + " -----\n", + " When ``USE_MD`` is enabled, the function also reports available OpenMM\n", + " platforms and uses the same MD settings as the rest of the notebook.\n", + "\n", + " Examples\n", + " --------\n", + " >>> results = benchmark_pipeline(seed=0, n_beads=300, n_reps=3)\n", + " >>> results[\"median_wall_time_s\"] > 0\n", + " True\n", + "\n", + " \"\"\"\n", + "\n", + " seed = int(seed)\n", + " n_beads = int(n_beads)\n", + " n_reps = int(n_reps)\n", + "\n", + " cpu_logical = psutil.cpu_count(logical=True)\n", + " available_ram_gb = psutil.virtual_memory().available / 1e9\n", + "\n", + " platforms = None\n", + " active_platform = None\n", + " if USE_MD:\n", + " platforms = [\n", + " openmm.Platform.getPlatform(i).getName()\n", + " for i in range(openmm.Platform.getNumPlatforms())\n", + " ]\n", + " active_platform = (\n", + " \"CUDA\" if \"CUDA\" in platforms else\n", + " \"OpenCL\" if \"OpenCL\" in platforms else\n", + " \"CPU\"\n", + " )\n", + "\n", + " if print_report:\n", + " print(\"=\" * 62)\n", + " print(\" SYSTEM PROFILE\")\n", + " print(\"=\" * 62)\n", + " print(f\" OS : {platform.system()} {platform.release()}\")\n", + " print(f\" CPU (logical) : {cpu_logical} cores\")\n", + " print(f\" RAM available : {available_ram_gb:.1f} GB\")\n", + " if USE_MD:\n", + " print(f\" OpenMM Platforms: {platforms}\")\n", + " print(f\" Active Platform : {active_platform}\")\n", + " print(f\" Mode : {'MD (OpenMM)' if USE_MD else 'Non-MD (2D Walk)'}\")\n", + " print()\n", + "\n", + " print(\"=\" * 62)\n", + " print(\" RUNNING BENCHMARK\")\n", + " print(\"=\" * 62)\n", + "\n", + " wall_times: list[float] = []\n", + " stage_timings: list[dict[str, float]] = []\n", + "\n", + " mem_tracker = _PeakMemTracker()\n", + " mem_tracker.start()\n", + "\n", + " for rep in range(n_reps):\n", + " rep_seed = seed + rep\n", + " t0 = time.perf_counter()\n", + " rep_stage_timings = _bench_stages(rep_seed, n_beads)\n", + " elapsed = time.perf_counter() - t0\n", + "\n", + " wall_times.append(elapsed)\n", + " stage_timings.append(rep_stage_timings)\n", + "\n", + " if print_report:\n", + " print(f\" Rep {rep + 1}/{n_reps}: {elapsed:.2f}s\")\n", + "\n", + " mem_tracker.stop()\n", + "\n", + " median_wall_time_s = statistics.median(wall_times)\n", + " mean_wall_time_s = statistics.mean(wall_times)\n", + "\n", + " stage_keys = stage_timings[0].keys() if stage_timings else []\n", + " median_stage_times_s = {\n", + " key: statistics.median(t[key] for t in stage_timings)\n", + " for key in stage_keys\n", + " }\n", + " ts = total_samples\n", + " projected_total_hours = None\n", + " if ts is not None:\n", + " projected_total_hours = (median_wall_time_s * int(ts)) / 3600\n", + "\n", + " if print_report:\n", + " print(\"=\" * 62)\n", + " print(f\" Median Wall Time: {median_wall_time_s:.2f} s\")\n", + " print(f\" Mean Wall Time : {mean_wall_time_s:.2f} s\")\n", + " print(f\" Peak RAM (RSS) : {mem_tracker.peak_mb:.1f} MB\")\n", + " if projected_total_hours is not None:\n", + " print(\n", + " f\" Projected Total : {projected_total_hours:.1f} hours \"\n", + " f\"for {int(ts)} samples\"\n", + " )\n", + " print(\"=\" * 62)\n", + "\n", + " return {\n", + " \"seed\": seed,\n", + " \"n_beads\": n_beads,\n", + " \"n_reps\": n_reps,\n", + " \"mode\": \"md\" if USE_MD else \"non_md\",\n", + " \"cpu_logical\": cpu_logical,\n", + " \"available_ram_gb\": available_ram_gb,\n", + " \"openmm_platforms\": platforms,\n", + " \"active_platform\": active_platform,\n", + " \"wall_times_s\": wall_times,\n", + " \"stage_timings_s\": stage_timings,\n", + " \"median_wall_time_s\": median_wall_time_s,\n", + " \"mean_wall_time_s\": mean_wall_time_s,\n", + " \"median_stage_times_s\": median_stage_times_s,\n", + " \"peak_rss_mb\": mem_tracker.peak_mb,\n", + " \"total_samples\": int(ts) if ts is not None else None,\n", + " \"projected_total_hours\": projected_total_hours,\n", + " }\n", + "\n", + "\n", + "BENCH_SEED = int(BASE_SEED)\n", + "BENCH_N_BEADS = int(BEAD_COUNTS[0])\n", + "BENCH_REPS = 3\n", + "\n", + "benchmark_results = benchmark_pipeline(\n", + " seed=BENCH_SEED,\n", + " n_beads=BENCH_N_BEADS,\n", + " n_reps=BENCH_REPS,\n", + " total_samples=int(N_SAMPLES) * len(BEAD_COUNTS),\n", + " print_report=True,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "cell_md_12", + "metadata": { + "id": "cell_md_12" + }, + "source": [ + "## 14.Dataset Generation\n", + "\n", + "Finally, we are ready to generate the full dataset. The amount of samples and the lenghts of the chains is defined in the global variables and will be referenced here.\n", + "This notebook generates the full dataset (default: 1000 samples × 4 chain lengths). There is added functionality to preview the images for a gives set or range of indices.\n", + "\n", + "\n", + "Progress is printed every 10 samples and a `manifest.csv` tracks all file paths." + ] + }, + { + "cell_type": "code", + "execution_count": 243, + "id": "cell_code_12", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cell_code_12", + "outputId": "46413bf7-4565-4337-f7e6-a21e8c4ac849" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting dataset generation: 1000 samples...\n", + "Skipping seed 7 due to OpenMMException: Energy or force at minimization starting point is infinite or NaN.\n", + "Progress: 10/1000\n", + "Skipping seed 12 due to OpenMMException: Energy or force at minimization starting point is infinite or NaN.\n", + "Progress: 20/1000\n", + "Skipping seed 31 due to OpenMMException: Energy or force at minimization starting point is infinite or NaN.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Progress: 30/1000\n", + "Progress: 40/1000\n", + "Skipping seed 45 due to TimeoutError: Simulation took too long!\n", + "Progress: 50/1000\n", + "Progress: 60/1000\n", + "Skipping seed 70 due to MemoryError: Unable to allocate 6.38 TiB for an array with shape (1260930, 1391400) and data type float32\n", + "Progress: 70/1000\n", + "Progress: 80/1000\n", + "Skipping seed 87 due to OpenMMException: Energy or force at minimization starting point is infinite or NaN.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Skipping seed 89 due to OpenMMException: Energy or force at minimization starting point is infinite or NaN.\n", + "Skipping seed 92 due to OpenMMException: Energy or force at minimization starting point is infinite or NaN.\n", + "Progress: 90/1000\n", + "Progress: 100/1000\n", + "Progress: 110/1000\n", + "Skipping seed 123 due to OpenMMException: Energy or force at minimization starting point is infinite or NaN.\n", + "Progress: 120/1000\n", + "Progress: 130/1000\n", + "Progress: 140/1000\n", + "Progress: 150/1000\n", + "Skipping seed 166 due to OpenMMException: Energy or force at minimization starting point is infinite or NaN.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Progress: 160/1000\n", + "Progress: 170/1000\n", + "Progress: 180/1000\n", + "Progress: 190/1000\n", + "Progress: 200/1000\n", + "Progress: 210/1000\n", + "Progress: 220/1000\n", + "Progress: 230/1000\n", + "Progress: 240/1000\n", + "Progress: 250/1000\n", + "Progress: 260/1000\n", + "Progress: 270/1000\n", + "Progress: 280/1000\n", + "Progress: 290/1000\n", + "Progress: 300/1000\n", + "Progress: 310/1000\n", + "Progress: 320/1000\n", + "Progress: 330/1000\n", + "Progress: 340/1000\n", + "Progress: 350/1000\n", + "Progress: 360/1000\n", + "Progress: 370/1000\n", + "Progress: 380/1000\n", + "Progress: 390/1000\n", + "Progress: 400/1000\n", + "Progress: 410/1000\n", + "Progress: 420/1000\n", + "Progress: 430/1000\n", + "Progress: 440/1000\n", + "Progress: 450/1000\n", + "Progress: 460/1000\n", + "Progress: 470/1000\n", + "Skipping seed 484 due to OpenMMException: Energy or force at minimization starting point is infinite or NaN.\n", + "Progress: 480/1000\n", + "Progress: 490/1000\n", + "Progress: 500/1000\n", + "Skipping seed 521 due to OpenMMException: Energy or force at minimization starting point is infinite or NaN.\n", + "Progress: 510/1000\n", + "Progress: 520/1000\n", + "Progress: 530/1000\n", + "Progress: 540/1000\n", + "Skipping seed 555 due to OpenMMException: Energy or force at minimization starting point is infinite or NaN.\n", + "Progress: 550/1000\n", + "Progress: 560/1000\n", + "Progress: 570/1000\n", + "Progress: 580/1000\n", + "Progress: 590/1000\n", + "Progress: 600/1000\n", + "Progress: 610/1000\n", + "Progress: 620/1000\n", + "Progress: 630/1000\n", + "Progress: 640/1000\n", + "Progress: 650/1000\n", + "Skipping seed 665 due to OpenMMException: Energy or force at minimization starting point is infinite or NaN.\n", + "Progress: 660/1000\n", + "Progress: 670/1000\n", + "Progress: 680/1000\n", + "Progress: 690/1000\n", + "Progress: 700/1000\n", + "Skipping seed 719 due to OpenMMException: Energy or force at minimization starting point is infinite or NaN.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Progress: 710/1000\n", + "Progress: 720/1000\n", + "Progress: 730/1000\n", + "Progress: 740/1000\n", + "Skipping seed 757 due to OpenMMException: Energy or force at minimization starting point is infinite or NaN.\n", + "Skipping seed 761 due to OpenMMException: Energy or force at minimization starting point is infinite or NaN.\n", + "Progress: 750/1000\n", + "Progress: 760/1000\n", + "Progress: 770/1000\n", + "Skipping seed 790 due to OpenMMException: Energy or force at minimization starting point is infinite or NaN.\n", + "Progress: 780/1000\n", + "Progress: 790/1000\n", + "Progress: 800/1000\n", + "Skipping seed 823 due to OpenMMException: Energy or force at minimization starting point is infinite or NaN.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Progress: 810/1000\n", + "Progress: 820/1000\n", + "Progress: 830/1000\n", + "Progress: 840/1000\n", + "Progress: 850/1000\n", + "Progress: 860/1000\n", + "Progress: 870/1000\n", + "Progress: 880/1000\n", + "Progress: 890/1000\n", + "Skipping seed 910 due to OpenMMException: Energy or force at minimization starting point is infinite or NaN.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Skipping seed 920 due to OpenMMException: Energy or force at minimization starting point is infinite or NaN.\n", + "Progress: 900/1000\n", + "Progress: 910/1000\n", + "Progress: 920/1000\n", + "Progress: 930/1000\n", + "Progress: 940/1000\n", + "Progress: 950/1000\n", + "Progress: 960/1000\n", + "Progress: 970/1000\n", + "Progress: 980/1000\n", + "Skipping seed 1008 due to TimeoutError: Simulation took too long!\n", + "Skipping seed 1009 due to TimeoutError: Simulation took too long!\n", + "Skipping seed 1010 due to TimeoutError: Simulation took too long!\n", + "Skipping seed 1011 due to TimeoutError: Simulation took too long!\n", + "Skipping seed 1012 due to OpenMMException: Energy or force at minimization starting point is infinite or NaN.\n", + "Skipping seed 1013 due to TimeoutError: Simulation took too long!\n", + "Skipping seed 1014 due to TimeoutError: Simulation took too long!\n", + "Skipping seed 1015 due to TimeoutError: Simulation took too long!\n", + "Using CUDA platform.\n", + "Skipping seed 1016 due to TimeoutError: Simulation took too long!\n", + "Skipping seed 1017 due to TimeoutError: Simulation took too long!\n", + "Using CUDA platform.\n", + "Skipping seed 1018 due to TimeoutError: Simulation took too long!\n", + "Skipping seed 1019 due to TimeoutError: Simulation took too long!\n", + "Using CUDA platform.\n", + "Skipping seed 1020 due to TimeoutError: Simulation took too long!\n", + "Skipping seed 1021 due to TimeoutError: Simulation took too long!\n", + "Using CUDA platform.\n", + "Skipping seed 1022 due to TimeoutError: Simulation took too long!\n", + "Skipping seed 1023 due to TimeoutError: Simulation took too long!\n", + "Using CUDA platform.\n", + "Using CUDA platform.\n", + "Progress: 990/1000\n", + "Progress: 1000/1000\n", + "\n", + "Done. Dataset written to: dna_dataset_unnormalized_1000_4lengths_MD\n", + "Manifest: dna_dataset_unnormalized_1000_4lengths_MD/manifest.csv\n" + ] + } + ], + "source": [ + "import csv\n", + "import json\n", + "import os\n", + "import subprocess\n", + "import sys\n", + "import time\n", + "from concurrent.futures import TimeoutError as FutureTimeoutError\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "try:\n", + " from joblib.externals.loky import get_reusable_executor\n", + "except ImportError:\n", + " subprocess.check_call(\n", + " [sys.executable, \"-m\", \"pip\", \"install\", \"joblib\"]\n", + " )\n", + " from joblib.externals.loky import get_reusable_executor\n", + "\n", + "\n", + "SAMPLE_TIMEOUT_S = 10.0 #How long to wait for every seed before skipping\n", + "_SAMPLE_EXECUTOR = None\n", + "\n", + "\n", + "def get_sample_executor():\n", + " \"\"\"Return the reusable process executor for sample generation.\n", + "\n", + " The executor runs sample generation in a separate Python process.\n", + " This makes the timeout independent of operating-system-specific\n", + " signal handling, so it works on Linux, macOS, and Windows.\n", + "\n", + " Returns\n", + " -------\n", + " loky.reusable_executor._ReusablePoolExecutor\n", + " Executor used to run one simulation task at a time.\n", + "\n", + " Notes\n", + " -----\n", + " The executor is created only when it is actually needed. After that, the\n", + " same executor is reused for future samples. That avoids creating a\n", + " brand-new process for every seed, which would be much slower.\n", + "\n", + " \"\"\"\n", + "\n", + " global _SAMPLE_EXECUTOR\n", + "\n", + " if _SAMPLE_EXECUTOR is None:\n", + " _SAMPLE_EXECUTOR = get_reusable_executor(max_workers=1)\n", + "\n", + " return _SAMPLE_EXECUTOR\n", + "\n", + "\n", + "def reset_sample_executor():\n", + " \"\"\"Shut down and recreate the sample-generation process pool.\n", + "\n", + " This is called after a timeout or worker-side exception. Killing the\n", + " worker prevents a long-running OpenMM calculation from continuing in\n", + " the background after the seed has already been skipped.\n", + "\n", + " Returns\n", + " -------\n", + " None\n", + "\n", + " \"\"\"\n", + "\n", + " global _SAMPLE_EXECUTOR\n", + "\n", + " if _SAMPLE_EXECUTOR is not None:\n", + " _SAMPLE_EXECUTOR.shutdown(\n", + " wait=False,\n", + " kill_workers=True,\n", + " )\n", + "\n", + " _SAMPLE_EXECUTOR = None\n", + "\n", + "\n", + "def generate_sample_worker(seed, n_beads, add_decoy):\n", + " \"\"\"Generate one DNA sample inside the worker process.\n", + "\n", + " Parameters\n", + " ----------\n", + " seed : int\n", + " Random seed used by the DNA simulator.\n", + " n_beads : int\n", + " Number of beads in the simulated DNA chain.\n", + " add_decoy : bool\n", + " Whether an additional decoy DNA chain should be included.\n", + "\n", + " Returns\n", + " -------\n", + " dict\n", + " Sample dictionary returned by ``generate_one_sample_multilength``.\n", + " It is expected to contain ``afm_img``, ``dna_mask``,\n", + " ``cross_mask``, ``seed``, ``n_beads``, ``extent``, and\n", + " ``n_crossings``.\n", + "\n", + " \"\"\"\n", + "\n", + " return generate_one_sample_multilength(\n", + " int(seed),\n", + " n_beads=int(n_beads),\n", + " noise_source=noise_source,\n", + " noise_asset=noise_asset,\n", + " add_decoy=bool(add_decoy),\n", + " )\n", + "\n", + "\n", + "def generate_sample_with_timeout(seed, n_beads, add_decoy):\n", + " \"\"\"Generate and validate one DNA sample with a time limit.\n", + "\n", + " The simulation is submitted to a separate process. If it does not\n", + " finish within ``SAMPLE_TIMEOUT_S`` seconds, the worker is killed and\n", + " the caller can skip the seed. Exceptions raised by OpenMM or by the\n", + " simulation code are also propagated so the seed can be skipped.\n", + "\n", + " Parameters\n", + " ----------\n", + " seed : int\n", + " Candidate random seed for the sample.\n", + " n_beads : int\n", + " Number of beads to simulate.\n", + " add_decoy : bool\n", + " Whether to add a decoy chain to this sample.\n", + "\n", + " Returns\n", + " -------\n", + " dict\n", + " Validated generated sample.\n", + "\n", + " Raises\n", + " ------\n", + " TimeoutError\n", + " If sample generation takes longer than ``SAMPLE_TIMEOUT_S``.\n", + " ValueError\n", + " If one of the output arrays contains non-finite values.\n", + " Exception\n", + " Re-raises any exception from the simulator.\n", + "\n", + " \"\"\"\n", + "\n", + " executor = get_sample_executor()\n", + " start_time = time.perf_counter()\n", + "\n", + " future = executor.submit(\n", + " generate_sample_worker,\n", + " int(seed),\n", + " int(n_beads),\n", + " bool(add_decoy),\n", + " )\n", + "\n", + " try:\n", + " sample = future.result(timeout=SAMPLE_TIMEOUT_S)\n", + " except FutureTimeoutError as exc:\n", + " future.cancel()\n", + " reset_sample_executor()\n", + " raise TimeoutError(\"Simulation took too long!\") from exc\n", + " except Exception:\n", + " future.cancel()\n", + " reset_sample_executor()\n", + " raise\n", + "\n", + " elapsed = time.perf_counter() - start_time\n", + "\n", + " if elapsed > SAMPLE_TIMEOUT_S:\n", + " reset_sample_executor()\n", + " raise TimeoutError(\"Simulation took too long!\")\n", + "\n", + " for key in (\"afm_img\", \"dna_mask\", \"cross_mask\"):\n", + " arr = np.asarray(sample[key])\n", + " if not np.all(np.isfinite(arr)):\n", + " raise ValueError(f\"Non-finite values found in {key}\")\n", + "\n", + " return sample\n", + "\n", + "\n", + "def save_preview_png(sample, idx, preview_dir):\n", + " \"\"\"Save visual PNG file previews for generated samples.\n", + "\n", + " The preview is useful for quickly checking that the generated AFM\n", + " image looks reasonable without opening the NumPy arrays manually.\n", + " This function only saves the AFM image, not the masks.\n", + "\n", + " Parameters\n", + " ----------\n", + " sample : dict\n", + " Generated sample dictionary containing ``afm_img``.\n", + " idx : int\n", + " Dataset index used to name the preview file.\n", + " preview_dir : str\n", + " Directory where preview PNG files are written.\n", + "\n", + " Returns\n", + " -------\n", + " str\n", + " Path to the written preview PNG file.\n", + "\n", + " \"\"\"\n", + "\n", + " preview_path = os.path.join(\n", + " preview_dir,\n", + " f\"preview_{idx:04d}.png\",\n", + " )\n", + "\n", + " plt.figure(figsize=(5, 5))\n", + " plt.imshow(sample[\"afm_img\"], cmap=\"gray\")\n", + " plt.axis(\"off\")\n", + " plt.tight_layout()\n", + " plt.savefig(preview_path, dpi=150)\n", + " plt.close()\n", + "\n", + " return preview_path\n", + "\n", + "manifest_path = os.path.join(OUT_DIR, \"manifest.csv\")\n", + "print(f\"Starting dataset generation: {N_SAMPLES} samples...\")\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# Choose indices to export as PNG previews.\n", + "# Examples:\n", + "# set(range(4, 41)) -> export indices 4 through 40 inclusive\n", + "# {0, 3, 10, 25} -> export only specific indices\n", + "# set() -> export none\n", + "EXPORT_PREVIEW_PNGS = False\n", + "PREVIEW_PNG_INDICES = set(range(4, 8))\n", + "PREVIEW_PNG_DIR = os.path.join(OUT_DIR, \"preview_pngs\")\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "\n", + "for subdir in (\"images\", \"dna_masks\", \"cross_masks\", \"meta\"):\n", + " os.makedirs(os.path.join(OUT_DIR, subdir), exist_ok=True)\n", + "\n", + "if EXPORT_PREVIEW_PNGS:\n", + " os.makedirs(PREVIEW_PNG_DIR, exist_ok=True)\n", + "\n", + "header = [\n", + " \"index\",\n", + " \"seed\",\n", + " \"n_beads\",\n", + " \"bond_length\",\n", + " \"persistence_bonds\",\n", + " \"image_npy\",\n", + " \"dna_mask_npy\",\n", + " \"cross_mask_npy\",\n", + " \"meta_npz\",\n", + " \"n_crossings\",\n", + " \"has_decoy\",\n", + " \"afm_params_json\",\n", + "]\n", + "\n", + "with open(manifest_path, \"w\", newline=\"\") as f:\n", + " writer = csv.writer(f)\n", + " writer.writerow(header)\n", + "\n", + " idx = 0\n", + " current_seed = int(BASE_SEED)\n", + "\n", + " while idx < int(N_SAMPLES):\n", + " n_beads = int(BEAD_COUNTS[idx % len(BEAD_COUNTS)])\n", + " add_decoy = bool(idx % 4 == 0)\n", + "\n", + " try:\n", + " sample = generate_sample_with_timeout(\n", + " current_seed,\n", + " n_beads,\n", + " add_decoy,\n", + " )\n", + "\n", + " img_path = os.path.join(\"images\", f\"img_{idx:04d}.npy\")\n", + " dna_path = os.path.join(\"dna_masks\", f\"dna_{idx:04d}.npy\")\n", + " cross_path = os.path.join(\n", + " \"cross_masks\",\n", + " f\"cross_{idx:04d}.npy\",\n", + " )\n", + " meta_path = os.path.join(\"meta\", f\"meta_{idx:04d}.npz\")\n", + "\n", + " np.save(os.path.join(OUT_DIR, img_path), sample[\"afm_img\"])\n", + " np.save(os.path.join(OUT_DIR, dna_path), sample[\"dna_mask\"])\n", + " np.save(\n", + " os.path.join(OUT_DIR, cross_path),\n", + " sample[\"cross_mask\"],\n", + " )\n", + "\n", + " np.savez_compressed(\n", + " os.path.join(OUT_DIR, meta_path),\n", + " seed=sample[\"seed\"],\n", + " n_beads=int(sample[\"n_beads\"]),\n", + " extent=sample[\"extent\"],\n", + " n_crossings=sample[\"n_crossings\"],\n", + " has_decoy=add_decoy,\n", + " bond_length=BOND_LENGTH,\n", + " persistence=PERSISTENCE_BONDS,\n", + " )\n", + "\n", + " afm_params = globals().get(\n", + " \"AF_KW\",\n", + " globals().get(\"AFM_KW\", {}),\n", + " )\n", + "\n", + " writer.writerow(\n", + " [\n", + " idx,\n", + " current_seed,\n", + " n_beads,\n", + " BOND_LENGTH,\n", + " PERSISTENCE_BONDS,\n", + " img_path,\n", + " dna_path,\n", + " cross_path,\n", + " meta_path,\n", + " sample[\"n_crossings\"],\n", + " add_decoy,\n", + " json.dumps(afm_params, default=str),\n", + " ]\n", + " )\n", + "\n", + " if EXPORT_PREVIEW_PNGS and idx in PREVIEW_PNG_INDICES:\n", + " save_preview_png(\n", + " sample,\n", + " idx,\n", + " PREVIEW_PNG_DIR,\n", + " )\n", + "\n", + " if (idx + 1) % 10 == 0:\n", + " print(f\"Progress: {idx + 1}/{N_SAMPLES}\")\n", + "\n", + " idx += 1\n", + " current_seed += 1\n", + "\n", + " except Exception as exc:\n", + " print(\n", + " f\"Skipping seed {current_seed} due to \"\n", + " f\"{type(exc).__name__}: {exc}\"\n", + " )\n", + " current_seed += 1\n", + " continue\n", + "\n", + "reset_sample_executor()\n", + "\n", + "print(\"\\nDone. Dataset written to:\", OUT_DIR)\n", + "print(\"Manifest:\", manifest_path)" + ] + }, + { + "cell_type": "markdown", + "id": "5boiiKowhLPJ", + "metadata": { + "id": "5boiiKowhLPJ" + }, + "source": [ + "# 15. DeepTrack source connection and Deeplay U-Net\n", + "\n", + "Run the dataset-generation cell above first, or point `OUT_DIR` and\n", + "`manifest_path` to an already generated dataset. This section reads the\n", + "manifest written by the simulation notebook, creates DeepTrack sources,\n", + "loads the `.npy` files lazily, and trains a simple Deeplay U-Net." + ] + }, + { + "cell_type": "code", + "execution_count": 244, + "id": "96164f45", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: deeplay in /opt/conda/lib/python3.11/site-packages (0.1.4)\n", + "Requirement already satisfied: numpy in /opt/conda/lib/python3.11/site-packages (from deeplay) (1.26.4)\n", + "Requirement already satisfied: matplotlib in /opt/conda/lib/python3.11/site-packages (from deeplay) (3.8.4)\n", + "Requirement already satisfied: torch>2.3 in /opt/conda/lib/python3.11/site-packages (from deeplay) (2.5.1+cu121)\n", + "Requirement already satisfied: lightning in /opt/conda/lib/python3.11/site-packages (from deeplay) (2.6.1)\n", + "Requirement already satisfied: torchmetrics in /opt/conda/lib/python3.11/site-packages (from deeplay) (1.9.0)\n", + "Requirement already satisfied: torchvision in /opt/conda/lib/python3.11/site-packages (from deeplay) (0.20.1+cu121)\n", + "Requirement already satisfied: torch-geometric in /opt/conda/lib/python3.11/site-packages (from deeplay) (2.7.0)\n", + "Requirement already satisfied: kornia in /opt/conda/lib/python3.11/site-packages (from deeplay) (0.8.2)\n", + "Requirement already satisfied: scipy in /opt/conda/lib/python3.11/site-packages (from deeplay) (1.13.0)\n", + "Requirement already satisfied: scikit-image in /opt/conda/lib/python3.11/site-packages (from deeplay) (0.22.0)\n", + "Requirement already satisfied: rich in /opt/conda/lib/python3.11/site-packages (from deeplay) (15.0.0)\n", + "Requirement already satisfied: dill in /opt/conda/lib/python3.11/site-packages (from deeplay) (0.3.8)\n", + "Requirement already satisfied: filelock in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (3.9.0)\n", + "Requirement already satisfied: typing-extensions>=4.8.0 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (4.11.0)\n", + "Requirement already satisfied: networkx in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (3.3)\n", + "Requirement already satisfied: jinja2 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (3.1.3)\n", + "Requirement already satisfied: fsspec in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (2024.3.1)\n", + "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.1.105 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (12.1.105)\n", + "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.1.105 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (12.1.105)\n", + "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.1.105 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (12.1.105)\n", + "Requirement already satisfied: nvidia-cudnn-cu12==9.1.0.70 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (9.1.0.70)\n", + "Requirement already satisfied: nvidia-cublas-cu12==12.1.3.1 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (12.1.3.1)\n", + "Requirement already satisfied: nvidia-cufft-cu12==11.0.2.54 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (11.0.2.54)\n", + "Requirement already satisfied: nvidia-curand-cu12==10.3.2.106 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (10.3.2.106)\n", + "Requirement already satisfied: nvidia-cusolver-cu12==11.4.5.107 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (11.4.5.107)\n", + "Requirement already satisfied: nvidia-cusparse-cu12==12.1.0.106 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (12.1.0.106)\n", + "Requirement already satisfied: nvidia-nccl-cu12==2.21.5 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (2.21.5)\n", + "Requirement already satisfied: nvidia-nvtx-cu12==12.1.105 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (12.1.105)\n", + "Requirement already satisfied: triton==3.1.0 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (3.1.0)\n", + "Requirement already satisfied: sympy==1.13.1 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (1.13.1)\n", + "Requirement already satisfied: nvidia-nvjitlink-cu12 in /opt/conda/lib/python3.11/site-packages (from nvidia-cusolver-cu12==11.4.5.107->torch>2.3->deeplay) (12.4.127)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /opt/conda/lib/python3.11/site-packages (from sympy==1.13.1->torch>2.3->deeplay) (1.3.0)\n", + "Requirement already satisfied: kornia_rs>=0.1.9 in /opt/conda/lib/python3.11/site-packages (from kornia->deeplay) (0.1.11)\n", + "Requirement already satisfied: packaging in /opt/conda/lib/python3.11/site-packages (from kornia->deeplay) (24.0)\n", + "Requirement already satisfied: PyYAML<8.0,>5.4 in /opt/conda/lib/python3.11/site-packages (from lightning->deeplay) (6.0.1)\n", + "Requirement already satisfied: lightning-utilities<2.0,>=0.10.0 in /opt/conda/lib/python3.11/site-packages (from lightning->deeplay) (0.15.3)\n", + "Requirement already satisfied: tqdm<6.0,>=4.57.0 in /opt/conda/lib/python3.11/site-packages (from lightning->deeplay) (4.66.2)\n", + "Requirement already satisfied: pytorch-lightning in /opt/conda/lib/python3.11/site-packages (from lightning->deeplay) (2.6.1)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /opt/conda/lib/python3.11/site-packages (from matplotlib->deeplay) (1.2.1)\n", + "Requirement already satisfied: cycler>=0.10 in /opt/conda/lib/python3.11/site-packages (from matplotlib->deeplay) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /opt/conda/lib/python3.11/site-packages (from matplotlib->deeplay) (4.51.0)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /opt/conda/lib/python3.11/site-packages (from matplotlib->deeplay) (1.4.5)\n", + "Requirement already satisfied: pillow>=8 in /opt/conda/lib/python3.11/site-packages (from matplotlib->deeplay) (10.3.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /opt/conda/lib/python3.11/site-packages (from matplotlib->deeplay) (3.1.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /opt/conda/lib/python3.11/site-packages (from matplotlib->deeplay) (2.9.0)\n", + "Requirement already satisfied: markdown-it-py>=2.2.0 in /opt/conda/lib/python3.11/site-packages (from rich->deeplay) (4.2.0)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /opt/conda/lib/python3.11/site-packages (from rich->deeplay) (2.17.2)\n", + "Requirement already satisfied: imageio>=2.27 in /opt/conda/lib/python3.11/site-packages (from scikit-image->deeplay) (2.34.0)\n", + "Requirement already satisfied: tifffile>=2022.8.12 in /opt/conda/lib/python3.11/site-packages (from scikit-image->deeplay) (2024.4.18)\n", + "Requirement already satisfied: lazy_loader>=0.3 in /opt/conda/lib/python3.11/site-packages (from scikit-image->deeplay) (0.4)\n", + "Requirement already satisfied: aiohttp in /opt/conda/lib/python3.11/site-packages (from torch-geometric->deeplay) (3.13.5)\n", + "Requirement already satisfied: psutil>=5.8.0 in /opt/conda/lib/python3.11/site-packages (from torch-geometric->deeplay) (5.9.8)\n", + "Requirement already satisfied: requests in /opt/conda/lib/python3.11/site-packages (from torch-geometric->deeplay) (2.31.0)\n", + "Requirement already satisfied: xxhash in /opt/conda/lib/python3.11/site-packages (from torch-geometric->deeplay) (3.7.0)\n", + "Requirement already satisfied: aiohappyeyeballs>=2.5.0 in /opt/conda/lib/python3.11/site-packages (from aiohttp->torch-geometric->deeplay) (2.6.1)\n", + "Requirement already satisfied: aiosignal>=1.4.0 in /opt/conda/lib/python3.11/site-packages (from aiohttp->torch-geometric->deeplay) (1.4.0)\n", + "Requirement already satisfied: attrs>=17.3.0 in /opt/conda/lib/python3.11/site-packages (from aiohttp->torch-geometric->deeplay) (23.2.0)\n", + "Requirement already satisfied: frozenlist>=1.1.1 in /opt/conda/lib/python3.11/site-packages (from aiohttp->torch-geometric->deeplay) (1.8.0)\n", + "Requirement already satisfied: multidict<7.0,>=4.5 in /opt/conda/lib/python3.11/site-packages (from aiohttp->torch-geometric->deeplay) (6.7.1)\n", + "Requirement already satisfied: propcache>=0.2.0 in /opt/conda/lib/python3.11/site-packages (from aiohttp->torch-geometric->deeplay) (0.5.2)\n", + "Requirement already satisfied: yarl<2.0,>=1.17.0 in /opt/conda/lib/python3.11/site-packages (from aiohttp->torch-geometric->deeplay) (1.23.0)\n", + "Requirement already satisfied: mdurl~=0.1 in /opt/conda/lib/python3.11/site-packages (from markdown-it-py>=2.2.0->rich->deeplay) (0.1.2)\n", + "Requirement already satisfied: six>=1.5 in /opt/conda/lib/python3.11/site-packages (from python-dateutil>=2.7->matplotlib->deeplay) (1.16.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /opt/conda/lib/python3.11/site-packages (from jinja2->torch>2.3->deeplay) (2.1.5)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /opt/conda/lib/python3.11/site-packages (from requests->torch-geometric->deeplay) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /opt/conda/lib/python3.11/site-packages (from requests->torch-geometric->deeplay) (3.7)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /opt/conda/lib/python3.11/site-packages (from requests->torch-geometric->deeplay) (2.2.1)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /opt/conda/lib/python3.11/site-packages (from requests->torch-geometric->deeplay) (2024.2.2)\n" + ] + } + ], + "source": [ + "!pip install --upgrade deeplay" + ] + }, + { + "cell_type": "code", + "execution_count": 245, + "id": "-4_NfbGBhLPJ", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-4_NfbGBhLPJ", + "outputId": "307b0998-0031-4921-f736-f8524c6048e4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: deeptrack in /opt/conda/lib/python3.11/site-packages (2.0.1)\n", + "Requirement already satisfied: deeplay in /opt/conda/lib/python3.11/site-packages (0.1.4)\n", + "Requirement already satisfied: lightning in /opt/conda/lib/python3.11/site-packages (2.6.1)\n", + "Requirement already satisfied: pandas in /opt/conda/lib/python3.11/site-packages (2.2.2)\n", + "Requirement already satisfied: pillow in /opt/conda/lib/python3.11/site-packages (10.3.0)\n", + "Requirement already satisfied: numpy in /opt/conda/lib/python3.11/site-packages (from deeptrack) (1.26.4)\n", + "Requirement already satisfied: matplotlib in /opt/conda/lib/python3.11/site-packages (from deeptrack) (3.8.4)\n", + "Requirement already satisfied: scipy in /opt/conda/lib/python3.11/site-packages (from deeptrack) (1.13.0)\n", + "Requirement already satisfied: scikit-image in /opt/conda/lib/python3.11/site-packages (from deeptrack) (0.22.0)\n", + "Requirement already satisfied: more_itertools in /opt/conda/lib/python3.11/site-packages (from deeptrack) (11.0.2)\n", + "Requirement already satisfied: pint in /opt/conda/lib/python3.11/site-packages (from deeptrack) (0.25.3)\n", + "Requirement already satisfied: tqdm in /opt/conda/lib/python3.11/site-packages (from deeptrack) (4.66.2)\n", + "Requirement already satisfied: lazy_import in /opt/conda/lib/python3.11/site-packages (from deeptrack) (0.2.2)\n", + "Requirement already satisfied: rich in /opt/conda/lib/python3.11/site-packages (from deeptrack) (15.0.0)\n", + "Requirement already satisfied: gdown in /opt/conda/lib/python3.11/site-packages (from deeptrack) (6.0.0)\n", + "Requirement already satisfied: torch>2.3 in /opt/conda/lib/python3.11/site-packages (from deeplay) (2.5.1+cu121)\n", + "Requirement already satisfied: torchmetrics in /opt/conda/lib/python3.11/site-packages (from deeplay) (1.9.0)\n", + "Requirement already satisfied: torchvision in /opt/conda/lib/python3.11/site-packages (from deeplay) (0.20.1+cu121)\n", + "Requirement already satisfied: torch-geometric in /opt/conda/lib/python3.11/site-packages (from deeplay) (2.7.0)\n", + "Requirement already satisfied: kornia in /opt/conda/lib/python3.11/site-packages (from deeplay) (0.8.2)\n", + "Requirement already satisfied: dill in /opt/conda/lib/python3.11/site-packages (from deeplay) (0.3.8)\n", + "Requirement already satisfied: PyYAML<8.0,>5.4 in /opt/conda/lib/python3.11/site-packages (from lightning) (6.0.1)\n", + "Requirement already satisfied: fsspec<2028.0,>=2022.5.0 in /opt/conda/lib/python3.11/site-packages (from fsspec[http]<2028.0,>=2022.5.0->lightning) (2024.3.1)\n", + "Requirement already satisfied: lightning-utilities<2.0,>=0.10.0 in /opt/conda/lib/python3.11/site-packages (from lightning) (0.15.3)\n", + "Requirement already satisfied: packaging<27.0,>=23.0 in /opt/conda/lib/python3.11/site-packages (from lightning) (24.0)\n", + "Requirement already satisfied: typing-extensions<6.0,>4.5.0 in /opt/conda/lib/python3.11/site-packages (from lightning) (4.11.0)\n", + "Requirement already satisfied: pytorch-lightning in /opt/conda/lib/python3.11/site-packages (from lightning) (2.6.1)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /opt/conda/lib/python3.11/site-packages (from pandas) (2.9.0)\n", + "Requirement already satisfied: pytz>=2020.1 in /opt/conda/lib/python3.11/site-packages (from pandas) (2024.1)\n", + "Requirement already satisfied: tzdata>=2022.7 in /opt/conda/lib/python3.11/site-packages (from pandas) (2024.1)\n", + "Requirement already satisfied: aiohttp!=4.0.0a0,!=4.0.0a1 in /opt/conda/lib/python3.11/site-packages (from fsspec[http]<2028.0,>=2022.5.0->lightning) (3.13.5)\n", + "Requirement already satisfied: six>=1.5 in /opt/conda/lib/python3.11/site-packages (from python-dateutil>=2.8.2->pandas) (1.16.0)\n", + "Requirement already satisfied: filelock in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (3.9.0)\n", + "Requirement already satisfied: networkx in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (3.3)\n", + "Requirement already satisfied: jinja2 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (3.1.3)\n", + "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.1.105 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (12.1.105)\n", + "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.1.105 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (12.1.105)\n", + "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.1.105 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (12.1.105)\n", + "Requirement already satisfied: nvidia-cudnn-cu12==9.1.0.70 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (9.1.0.70)\n", + "Requirement already satisfied: nvidia-cublas-cu12==12.1.3.1 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (12.1.3.1)\n", + "Requirement already satisfied: nvidia-cufft-cu12==11.0.2.54 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (11.0.2.54)\n", + "Requirement already satisfied: nvidia-curand-cu12==10.3.2.106 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (10.3.2.106)\n", + "Requirement already satisfied: nvidia-cusolver-cu12==11.4.5.107 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (11.4.5.107)\n", + "Requirement already satisfied: nvidia-cusparse-cu12==12.1.0.106 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (12.1.0.106)\n", + "Requirement already satisfied: nvidia-nccl-cu12==2.21.5 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (2.21.5)\n", + "Requirement already satisfied: nvidia-nvtx-cu12==12.1.105 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (12.1.105)\n", + "Requirement already satisfied: triton==3.1.0 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (3.1.0)\n", + "Requirement already satisfied: sympy==1.13.1 in /opt/conda/lib/python3.11/site-packages (from torch>2.3->deeplay) (1.13.1)\n", + "Requirement already satisfied: nvidia-nvjitlink-cu12 in /opt/conda/lib/python3.11/site-packages (from nvidia-cusolver-cu12==11.4.5.107->torch>2.3->deeplay) (12.4.127)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /opt/conda/lib/python3.11/site-packages (from sympy==1.13.1->torch>2.3->deeplay) (1.3.0)\n", + "Requirement already satisfied: beautifulsoup4 in /opt/conda/lib/python3.11/site-packages (from gdown->deeptrack) (4.12.3)\n", + "Requirement already satisfied: requests[socks] in /opt/conda/lib/python3.11/site-packages (from gdown->deeptrack) (2.31.0)\n", + "Requirement already satisfied: kornia_rs>=0.1.9 in /opt/conda/lib/python3.11/site-packages (from kornia->deeplay) (0.1.11)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /opt/conda/lib/python3.11/site-packages (from matplotlib->deeptrack) (1.2.1)\n", + "Requirement already satisfied: cycler>=0.10 in /opt/conda/lib/python3.11/site-packages (from matplotlib->deeptrack) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /opt/conda/lib/python3.11/site-packages (from matplotlib->deeptrack) (4.51.0)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /opt/conda/lib/python3.11/site-packages (from matplotlib->deeptrack) (1.4.5)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /opt/conda/lib/python3.11/site-packages (from matplotlib->deeptrack) (3.1.2)\n", + "Requirement already satisfied: flexcache>=0.3 in /opt/conda/lib/python3.11/site-packages (from pint->deeptrack) (0.3)\n", + "Requirement already satisfied: flexparser>=0.4 in /opt/conda/lib/python3.11/site-packages (from pint->deeptrack) (0.4)\n", + "Requirement already satisfied: platformdirs>=2.1.0 in /opt/conda/lib/python3.11/site-packages (from pint->deeptrack) (4.2.0)\n", + "Requirement already satisfied: markdown-it-py>=2.2.0 in /opt/conda/lib/python3.11/site-packages (from rich->deeptrack) (4.2.0)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /opt/conda/lib/python3.11/site-packages (from rich->deeptrack) (2.17.2)\n", + "Requirement already satisfied: imageio>=2.27 in /opt/conda/lib/python3.11/site-packages (from scikit-image->deeptrack) (2.34.0)\n", + "Requirement already satisfied: tifffile>=2022.8.12 in /opt/conda/lib/python3.11/site-packages (from scikit-image->deeptrack) (2024.4.18)\n", + "Requirement already satisfied: lazy_loader>=0.3 in /opt/conda/lib/python3.11/site-packages (from scikit-image->deeptrack) (0.4)\n", + "Requirement already satisfied: psutil>=5.8.0 in /opt/conda/lib/python3.11/site-packages (from torch-geometric->deeplay) (5.9.8)\n", + "Requirement already satisfied: xxhash in /opt/conda/lib/python3.11/site-packages (from torch-geometric->deeplay) (3.7.0)\n", + "Requirement already satisfied: aiohappyeyeballs>=2.5.0 in /opt/conda/lib/python3.11/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<2028.0,>=2022.5.0->lightning) (2.6.1)\n", + "Requirement already satisfied: aiosignal>=1.4.0 in /opt/conda/lib/python3.11/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<2028.0,>=2022.5.0->lightning) (1.4.0)\n", + "Requirement already satisfied: attrs>=17.3.0 in /opt/conda/lib/python3.11/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<2028.0,>=2022.5.0->lightning) (23.2.0)\n", + "Requirement already satisfied: frozenlist>=1.1.1 in /opt/conda/lib/python3.11/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<2028.0,>=2022.5.0->lightning) (1.8.0)\n", + "Requirement already satisfied: multidict<7.0,>=4.5 in /opt/conda/lib/python3.11/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<2028.0,>=2022.5.0->lightning) (6.7.1)\n", + "Requirement already satisfied: propcache>=0.2.0 in /opt/conda/lib/python3.11/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<2028.0,>=2022.5.0->lightning) (0.5.2)\n", + "Requirement already satisfied: yarl<2.0,>=1.17.0 in /opt/conda/lib/python3.11/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<2028.0,>=2022.5.0->lightning) (1.23.0)\n", + "Requirement already satisfied: mdurl~=0.1 in /opt/conda/lib/python3.11/site-packages (from markdown-it-py>=2.2.0->rich->deeptrack) (0.1.2)\n", + "Requirement already satisfied: soupsieve>1.2 in /opt/conda/lib/python3.11/site-packages (from beautifulsoup4->gdown->deeptrack) (2.5)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /opt/conda/lib/python3.11/site-packages (from jinja2->torch>2.3->deeplay) (2.1.5)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /opt/conda/lib/python3.11/site-packages (from requests[socks]->gdown->deeptrack) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /opt/conda/lib/python3.11/site-packages (from requests[socks]->gdown->deeptrack) (3.7)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /opt/conda/lib/python3.11/site-packages (from requests[socks]->gdown->deeptrack) (2.2.1)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /opt/conda/lib/python3.11/site-packages (from requests[socks]->gdown->deeptrack) (2024.2.2)\n", + "Requirement already satisfied: PySocks!=1.5.7,>=1.5.6 in /opt/conda/lib/python3.11/site-packages (from requests[socks]->gdown->deeptrack) (1.7.1)\n" + ] + } + ], + "source": [ + "# Install these in a fresh Colab/Kaggle runtime.\n", + "!pip install deeptrack deeplay lightning pandas pillow" + ] + }, + { + "cell_type": "markdown", + "id": "5vJg1TV5u_ML", + "metadata": { + "id": "5vJg1TV5u_ML" + }, + "source": [ + "...and then we load the required dependencies and set up the model hyperparameters..." + ] + }, + { + "cell_type": "code", + "execution_count": 249, + "id": "KMncGnXzhLPM", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 356 + }, + "id": "KMncGnXzhLPM", + "outputId": "407e665f-296c-49ad-c614-7172947e3fa7" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Seed set to 7\n" + ] + } + ], + "source": [ + "from pathlib import Path\n", + "from typing import Any\n", + "\n", + "import random\n", + "\n", + "import deeplay as dl\n", + "import deeptrack as dt\n", + "import lightning as L\n", + "import numpy as np\n", + "import pandas as pd\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "from PIL import Image\n", + "from torch.utils.data import Dataset\n", + "\n", + "SEED = 7 #Seed for reproducibility\n", + "\n", + "L.seed_everything(SEED, workers=True)\n", + "random.seed(SEED)\n", + "np.random.seed(SEED)\n", + "torch.manual_seed(SEED)\n", + "manifest_path = Path(OUT_DIR) / \"manifest.csv\"\n", + "TARGET_SIZE = int(NX)\n", + "VAL_FRACTION = 0.20 #This corresponds to a 80:20 split of test and validation\n", + "BG_Q = 35\n", + "HIGH_Q = 99.98\n", + "\n", + "MODEL_CFG = dict(\n", + " in_channels=1,\n", + " channels=[32, 64, 128, 256],\n", + " out_channels=2,\n", + ")\n", + "\n", + "TRAIN_CFG = dict(\n", + " batch_size=4,\n", + " num_workers=0,\n", + " max_epochs=50,\n", + " lr=3e-4,\n", + " dna_pos_weight=1.6,\n", + " dna_loss_weight=1.0,\n", + " cross_loss_weight=0.25,\n", + " cross_pos_weight=50.0,\n", + " cross_false_positive_weight=1.0,\n", + " background_false_positive_weight=0.02,\n", + " dice_smooth=1.0,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "g0hlOwRfhLPM", + "metadata": { + "id": "g0hlOwRfhLPM" + }, + "source": [ + "# 16. Build DeepTrack sources from the simulation manifest\n", + "\n", + "The original manifest columns are `image_npy`, `dna_mask_npy`, and\n", + "`cross_mask_npy`. They are relative paths, so the loader joins them with\n", + "`OUT_DIR` before reading the files." + ] + }, + { + "cell_type": "code", + "execution_count": 252, + "id": "Y3bgtN9MhLPM", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Y3bgtN9MhLPM", + "outputId": "1beac707-db78-4993-9af4-fba5779f10ee" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total samples: 1000\n", + "Training samples: 800\n", + "Validation samples: 200\n", + "First source row: {'id': '0', 'image_path': 'dna_dataset_unnormalized_1000_4lengths_MD/images/img_0000.npy', 'dna_path': 'dna_dataset_unnormalized_1000_4lengths_MD/dna_masks/dna_0000.npy', 'cross_path': 'dna_dataset_unnormalized_1000_4lengths_MD/cross_masks/cross_0000.npy'}\n" + ] + } + ], + "source": [ + "IMAGE_COLUMNS = (\n", + " 'image_npy',\n", + " 'image_path',\n", + " 'img_path',\n", + " 'afm_path',\n", + ")\n", + "\n", + "DNA_COLUMNS = (\n", + " 'dna_mask_npy',\n", + " 'dna_path',\n", + " 'mask_path',\n", + " 'label_path',\n", + ")\n", + "\n", + "CROSS_COLUMNS = (\n", + " 'cross_mask_npy',\n", + " 'cross_path',\n", + " 'crossing_path',\n", + ")\n", + "\n", + "\n", + "def find_column(\n", + " frame: pd.DataFrame,\n", + " candidates: tuple[str, ...],\n", + " required: bool = True,\n", + ") -> str | None:\n", + " \"\"\"Return the first matching column in a manifest.\n", + "\n", + " Parameters\n", + " ----------\n", + " frame : pd.DataFrame\n", + " The dataframe to search for columns.\n", + " candidates : tuple[str, ...]\n", + " A tuple of potential column names to match.\n", + " required : bool, optional\n", + " If True, raises a KeyError if no matching column is found.\n", + " Defaults to True.\n", + "\n", + " Returns\n", + " -------\n", + " str | None\n", + " The name of the first matching column found, or None if no\n", + " match is found and `required` is False.\n", + "\n", + " Raises\n", + " ------\n", + " KeyError\n", + " If `required` is True and none of the `candidates` exist in `frame`.\n", + "\n", + " \"\"\"\n", + "\n", + " for column in candidates:\n", + " if column in frame.columns:\n", + " return column\n", + "\n", + " if required:\n", + " names = ', '.join(candidates)\n", + " raise KeyError(f'Manifest is missing one of: {names}')\n", + "\n", + " return None\n", + "\n", + "\n", + "def resolve_data_path(value: Any, root: Path) -> Path:\n", + " \"\"\"Resolve an absolute or OUT_DIR-relative file path.\n", + "\n", + " Parameters\n", + " ----------\n", + " value: any\n", + " The value to resolve.\n", + " root: Path\n", + " The root directory.\n", + "\n", + " Returns\n", + " -------\n", + " Path\n", + " The resolved path.\n", + "\n", + " \"\"\"\n", + "\n", + " path = Path(str(value))\n", + "\n", + " if path.is_absolute():\n", + " return path\n", + "\n", + " return Path(root) / path\n", + "\n", + "\n", + "def manifest_to_records(\n", + " frame: pd.DataFrame,\n", + " root: Path,\n", + ") -> list[dict[str, str]]:\n", + " \"\"\"Convert the simulation manifest to DeepTrack source rows.\n", + "\n", + " Parameters\n", + " ----------\n", + " frame: pd.dataframe\n", + " The simulation manifest.\n", + " root: Path\n", + " The root directory.\n", + "\n", + " Returns\n", + " -------\n", + " list[dict[str, str]]\n", + " A list of DeepTrack source rows.\n", + "\n", + " \"\"\"\n", + "\n", + " image_col = find_column(frame, IMAGE_COLUMNS)\n", + " dna_col = find_column(frame, DNA_COLUMNS)\n", + " cross_col = find_column(frame, CROSS_COLUMNS, required=False)\n", + " records = []\n", + " missing = []\n", + "\n", + " for row_index, row in frame.iterrows():\n", + " image_path = resolve_data_path(row[image_col], root)\n", + " dna_path = resolve_data_path(row[dna_col], root)\n", + " cross_path = ''\n", + "\n", + " if cross_col is not None and not pd.isna(row[cross_col]):\n", + " cross_path = str(resolve_data_path(row[cross_col], root))\n", + "\n", + " if not image_path.exists():\n", + " missing.append(str(image_path))\n", + " continue\n", + "\n", + " if not dna_path.exists():\n", + " missing.append(str(dna_path))\n", + " continue\n", + "\n", + " if cross_path and not Path(cross_path).exists():\n", + " missing.append(cross_path)\n", + " cross_path = ''\n", + "\n", + " sample_id = str(row.get('index', row_index))\n", + " records.append(\n", + " dict(\n", + " id=sample_id,\n", + " image_path=str(image_path),\n", + " dna_path=str(dna_path),\n", + " cross_path=cross_path,\n", + " )\n", + " )\n", + "\n", + " if missing:\n", + " preview = '\\n'.join(missing[:10])\n", + " raise FileNotFoundError(\n", + " 'Some manifest files could not be found. First missing files:\\n'\n", + " f'{preview}'\n", + " )\n", + "\n", + " if not records:\n", + " raise RuntimeError('No valid samples were found in the manifest.')\n", + "\n", + " return records\n", + "\n", + "\n", + "def split_records(\n", + " records: list[dict[str, str]],\n", + " val_fraction: float,\n", + " seed: int,\n", + ") -> tuple[list[dict[str, str]], list[dict[str, str]]]:\n", + " \"\"\"Split records into train and validation lists.\n", + "\n", + " Parameters\n", + " ----------\n", + " records: list\n", + " A list of DeepTrack source rows.\n", + " val_fraction: float\n", + " The fraction for the split between training and validation.\n", + " seed: int\n", + " Random seed for reproducibility.\n", + "\n", + " Returns\n", + " -------\n", + " tuple[list[dict[str, str]], list[dict[str, str]]]\n", + " A tuple of train and validation lists.\n", + "\n", + " \"\"\"\n", + "\n", + " if len(records) < 2:\n", + " return records, records\n", + "\n", + " rng = np.random.default_rng(seed)\n", + " order = rng.permutation(len(records))\n", + " n_val = max(1, int(round(len(records) * val_fraction)))\n", + " n_val = min(n_val, len(records) - 1)\n", + " val_index = set(int(i) for i in order[:n_val])\n", + " train_rows = []\n", + " val_rows = []\n", + "\n", + " for index, record in enumerate(records):\n", + " if index in val_index:\n", + " val_rows.append(record)\n", + " else:\n", + " train_rows.append(record)\n", + "\n", + " return train_rows, val_rows\n", + "\n", + "\n", + "manifest_file = Path(manifest_path)\n", + "dataset_root = Path(OUT_DIR)\n", + "\n", + "if not manifest_file.exists():\n", + " raise FileNotFoundError(\n", + " 'Run the dataset-generation cell first, or set manifest_path to an '\n", + " f'existing manifest. Current value: {manifest_file}'\n", + " )\n", + "\n", + "manifest_df = pd.read_csv(manifest_file)\n", + "all_records = manifest_to_records(manifest_df, dataset_root)\n", + "train_records, val_records = split_records(\n", + " all_records,\n", + " VAL_FRACTION,\n", + " SEED,\n", + ")\n", + "\n", + "train_source = dt.sources.Source(samples=train_records)\n", + "val_source = dt.sources.Source(samples=val_records)\n", + "\n", + "print('Total samples:', len(all_records))\n", + "print('Training samples:', len(train_source))\n", + "print('Validation samples:', len(val_source))\n", + "print('First source row:', train_records[0])" + ] + }, + { + "cell_type": "markdown", + "id": "A_rtdbEChLPM", + "metadata": { + "id": "A_rtdbEChLPM" + }, + "source": [ + "# 17. Lazy `.npy` loading pipeline\n", + "\n", + "The source stores only file paths. `dt.Value(source.samples)` resolves the\n", + "current manifest row, and `dt.Lambda` loads the image and masks lazily. All\n", + "flipped or rotated arrays are converted with `np.ascontiguousarray`, which\n", + "prevents negative-stride errors when creating PyTorch tensors." + ] + }, + { + "cell_type": "code", + "execution_count": 253, + "id": "uRSxyqK_hLPM", + "metadata": { + "id": "uRSxyqK_hLPM" + }, + "outputs": [], + "source": [ + "def load_array(path: str | Path) -> np.ndarray:\n", + " \"\"\"Load a NumPy array or image file as a 2-D float32 array.\n", + "\n", + " Parameters\n", + " ----------\n", + " path: str | Path\n", + " The path to the array or image file.\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray\n", + " The loaded array.\n", + "\n", + " \"\"\"\n", + "\n", + " path = Path(path)\n", + "\n", + " if path.suffix.lower() == '.npy':\n", + " array = np.load(path)\n", + " else:\n", + " with Image.open(path) as image:\n", + " array = np.asarray(image)\n", + "\n", + " array = np.asarray(array)\n", + "\n", + " if array.ndim == 3:\n", + " array = array[..., :3].mean(axis=-1)\n", + "\n", + " array = np.squeeze(array)\n", + " return np.asarray(array, dtype=np.float32)\n", + "\n", + "\n", + "def normalize_afm(\n", + " image: np.ndarray,\n", + " bg_q: float = BG_Q,\n", + " high_q: float = HIGH_Q,\n", + ") -> np.ndarray:\n", + " \"\"\"Normalize an AFM height map using robust percentiles.\n", + "\n", + " This function normalizes the image by converting the pixels below the 70th\n", + " percentile to 0 and everything above 99.95th percentile is mapped to 1.\n", + "\n", + " Parameters\n", + " ----------\n", + " image: np.ndarray\n", + " The height map to normalize.\n", + " bg_q: float\n", + " The percentile for the background. Defaults to BG_Q.\n", + " high_q: float\n", + " The percentile for the foreground. Defaults to HIGH_Q.\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray\n", + " The normalized height map.\n", + "\n", + " \"\"\"\n", + "\n", + " array = np.asarray(image, dtype=np.float32)\n", + " array = np.nan_to_num(array, copy=False)\n", + " low = float(np.percentile(array, bg_q))\n", + " high = float(np.percentile(array, high_q))\n", + " scale = max(high - low, 1e-6)\n", + " array = (array - low) / scale\n", + " return np.clip(array, 0.0, 1.0).astype(np.float32)\n", + "\n", + "\n", + "def resize_and_pad_np(\n", + " array: np.ndarray,\n", + " target_size: int,\n", + " mode: str,\n", + ") -> np.ndarray:\n", + " \"\"\"Resize an array isotropically and pad it to a square.\n", + "\n", + " Parameters\n", + " ----------\n", + " array : np.ndarray\n", + " The image for resizing if necessary.\n", + " target_size: int\n", + " the size of the required image.\n", + " mode : str\n", + " The resize mode.\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray\n", + " The resized array.\n", + "\n", + " \"\"\"\n", + "\n", + " array = np.asarray(array, dtype=np.float32)\n", + " array = np.nan_to_num(np.squeeze(array), copy=False)\n", + " array = np.ascontiguousarray(array)\n", + " height, width = array.shape[-2:]\n", + " target = int(target_size)\n", + " scale = min(target / height, target / width)\n", + " new_h = max(1, int(round(height * scale)))\n", + " new_w = max(1, int(round(width * scale)))\n", + " tensor = torch.from_numpy(array)[None, None].float()\n", + " kwargs: dict[str, Any] = dict(size=(new_h, new_w), mode=mode)\n", + "\n", + " if mode in {'bilinear', 'bicubic'}:\n", + " kwargs['align_corners'] = False\n", + "\n", + " resized = F.interpolate(tensor, **kwargs)[0, 0].numpy()\n", + " canvas = np.zeros((target, target), dtype=np.float32)\n", + " top = (target - new_h) // 2\n", + " left = (target - new_w) // 2\n", + " canvas[top:top + new_h, left:left + new_w] = resized\n", + " return np.ascontiguousarray(canvas)\n", + "\n", + "\n", + "def augment_triplet(\n", + " image: np.ndarray,\n", + " dna: np.ndarray,\n", + " cross: np.ndarray,\n", + ") -> tuple[np.ndarray, np.ndarray, np.ndarray]:\n", + " \"\"\"Apply the same simple geometric augmentation to all arrays.\n", + "\n", + " Parameters\n", + " ----------\n", + " image : np.ndarray\n", + " The image to augment.\n", + " dna : np.ndarray\n", + " The DNA mask to augment.\n", + " cross : np.ndarray\n", + " The crossing mask to augment.\n", + "\n", + " Returns\n", + " -------\n", + " tuple[np.ndarray, np.ndarray, np.ndarray]\n", + " The augmented arrays.\n", + "\n", + " \"\"\"\n", + "\n", + " if random.random() < 0.5:\n", + " image = np.fliplr(image)\n", + " dna = np.fliplr(dna)\n", + " cross = np.fliplr(cross)\n", + "\n", + " if random.random() < 0.5:\n", + " image = np.flipud(image)\n", + " dna = np.flipud(dna)\n", + " cross = np.flipud(cross)\n", + "\n", + " k = random.randint(0, 3)\n", + " if k:\n", + " image = np.rot90(image, k)\n", + " dna = np.rot90(dna, k)\n", + " cross = np.rot90(cross, k)\n", + "\n", + " return (\n", + " np.ascontiguousarray(image),\n", + " np.ascontiguousarray(dna),\n", + " np.ascontiguousarray(cross),\n", + " )\n", + "\n", + "\n", + "def load_sample_factory(\n", + " target_size: int = 512,\n", + " augment: bool = False,\n", + " normalize_image: bool = False,\n", + "):\n", + " \"\"\"Return a DeepTrack Lambda function for one manifest row.\n", + "\n", + " Parameters\n", + " ----------\n", + " target_size : int\n", + " The target size for the images and masks. Defaults to 512.\n", + " augment : bool\n", + " Whether to apply geometric augmentation. Defaults to False.\n", + " normalize_image: bool\n", + " Whether to normalize the image. Defaults to False. \n", + "\n", + " Returns\n", + " -------\n", + " dt.Lambda\n", + "\n", + " \"\"\"\n", + "\n", + " def load_sample(sample: dict[str, str]):\n", + " image = load_array(sample[\"image_path\"])\n", + " dna = load_array(sample[\"dna_path\"])\n", + "\n", + " image = np.nan_to_num(image, copy=False).astype(np.float32)\n", + "\n", + " if normalize_image:\n", + " image = normalize_afm(image)\n", + "\n", + " dna = (dna > 0.5).astype(np.float32)\n", + "\n", + " if sample.get(\"cross_path\"):\n", + " cross = load_array(sample[\"cross_path\"])\n", + " cross = np.nan_to_num(cross, copy=False)\n", + "\n", + " max_cross = float(np.max(cross))\n", + " if max_cross > 1.0:\n", + " cross = cross / max_cross\n", + "\n", + " cross = np.clip(cross, 0.0, 1.0).astype(np.float32)\n", + " else:\n", + " cross = np.zeros_like(dna, dtype=np.float32)\n", + "\n", + " if augment:\n", + " image, dna, cross = augment_triplet(image, dna, cross)\n", + "\n", + " image = resize_and_pad_np(image, target_size, \"bilinear\")\n", + " dna = resize_and_pad_np(dna, target_size, \"nearest\")\n", + " cross = resize_and_pad_np(cross, target_size, \"bilinear\")\n", + "\n", + " dna = (dna > 0.5).astype(np.float32)\n", + " cross = np.clip(cross, 0.0, 1.0).astype(np.float32)\n", + "\n", + " image = np.ascontiguousarray(image[None, :, :])\n", + " target = np.stack([dna, cross], axis=0)\n", + " target = np.ascontiguousarray(target.astype(np.float32))\n", + "\n", + " return image.astype(np.float32), target\n", + "\n", + " return load_sample\n", + "\n", + "\n", + "def build_pipeline(\n", + " source,\n", + " target_size: int,\n", + " augment: bool,\n", + " normalize_image: bool = False,\n", + "):\n", + " \"\"\"Create a DeepTrack pipeline from a source of manifest rows.\n", + "\n", + " Parameters\n", + " ----------\n", + " source : dt.Source\n", + " The source of manifest rows.\n", + " target_size: int\n", + " The target size for the images and masks.\n", + " augment : bool\n", + " Whether to apply geometric augmentation.\n", + " normalize_image : bool\n", + " Whether to normalize the image. Defaults to False. \n", + "\n", + " Returns\n", + " -------\n", + " dt.Pipeline\n", + "\n", + " \"\"\"\n", + "\n", + " sample_value = dt.Value(source.samples)\n", + "\n", + " loader = dt.Lambda(\n", + " function=load_sample_factory,\n", + " target_size=target_size,\n", + " augment=augment,\n", + " normalize_image=normalize_image,\n", + " )\n", + "\n", + " return sample_value >> loader" + ] + }, + { + "cell_type": "code", + "execution_count": 254, + "id": "bACdP_7khLPM", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bACdP_7khLPM", + "outputId": "d5fee6cb-d0f8-4e30-bc84-d41bd1b5de3c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "image batch: (4, 1, 512, 512) torch.float32\n", + "target batch: (4, 2, 512, 512) torch.float32\n", + "target channels: DNA = 0, crossings = 1\n" + ] + } + ], + "source": [ + "class DeepTrackSourceDataset(Dataset):\n", + " \"\"\"PyTorch dataset backed by a DeepTrack source and pipeline.\n", + "\n", + " This dataset connects a DeepTrack ``Source`` to a PyTorch-compatible\n", + " dataset interface. Each item is generated by evaluating a DeepTrack\n", + " pipeline on one source entry. The pipeline is expected to return an\n", + " image and a two-channel target array.\n", + "\n", + " The first target channel should contain the DNA segmentation mask.\n", + " The second target channel should contain the crossing target.\n", + "\n", + " Parameters\n", + " ----------\n", + " source : deeptrack.sources.Source\n", + " DeepTrack source containing one entry per sample.\n", + " target_size : int\n", + " Final spatial size used for image and target tensors.\n", + " augment : bool\n", + " Whether to apply training-time augmentation in the pipeline.\n", + " normalize_image : callable or Non\n", + " Optional function used to normalize the image. This function is\n", + " applied only to the image, not to the target. Defaults to None.\n", + "\n", + " Attributes\n", + " ----------\n", + " source : deeptrack.sources.Source\n", + " Source object used to index sample metadata or paths.\n", + " pipeline : deeptrack.Feature\n", + " DeepTrack pipeline built from ``source``, ``target_size``, and\n", + " ``augment``.\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " source,\n", + " target_size: int,\n", + " augment: bool,\n", + " normalize_image: bool = False,\n", + " ):\n", + " \"\"\"Initialize the dataset and build the DeepTrack pipeline.\n", + "\n", + " Parameters\n", + " ----------\n", + " source : deeptrack.sources.Source\n", + " DeepTrack source containing one entry per sample.\n", + " target_size : int\n", + " Final spatial size used for image and target tensors.\n", + " augment : bool\n", + " Whether to apply training-time augmentation in the pipeline.\n", + " \"\"\"\n", + " self.source = source\n", + " self.pipeline = build_pipeline(\n", + " source,\n", + " target_size,\n", + " augment,\n", + " normalize_image=normalize_image,\n", + " )\n", + "\n", + " def __len__(self) -> int:\n", + " \"\"\"Return the number of samples in the DeepTrack source.\n", + "\n", + " Returns\n", + " -------\n", + " int\n", + " Number of source entries available to the dataset.\n", + " \"\"\"\n", + " return len(self.source)\n", + "\n", + " @staticmethod\n", + " def _to_tensor(array: np.ndarray) -> torch.Tensor:\n", + " \"\"\"Convert an array-like object to a contiguous float tensor.\n", + "\n", + " This function also replaces NaN and infinite values with finite\n", + " numbers and ensures the array has positive strides. The positive\n", + " stride conversion is important after NumPy operations such as\n", + " flips or rotations, which can otherwise create views with\n", + " negative strides that PyTorch cannot convert directly.\n", + "\n", + " Parameters\n", + " ----------\n", + " array : np.ndarray\n", + " Array-like image or target returned by the DeepTrack\n", + " pipeline.\n", + "\n", + " Returns\n", + " -------\n", + " torch.Tensor\n", + " Contiguous ``float32`` tensor.\n", + "\n", + " \"\"\"\n", + "\n", + " array = np.asarray(array, dtype=np.float32)\n", + " array = np.nan_to_num(array, copy=False)\n", + " array = np.ascontiguousarray(array)\n", + " return torch.from_numpy(array).float()\n", + "\n", + " def __getitem__(self, index: int):\n", + " \"\"\"Return one image-target pair from the DeepTrack pipeline.\n", + "\n", + " Parameters\n", + " ----------\n", + " index : int\n", + " Index of the source entry to evaluate.\n", + "\n", + " Returns\n", + " -------\n", + " tuple[torch.Tensor, torch.Tensor]\n", + " Image tensor and target tensor. The target tensor is expected\n", + " to contain two channels: DNA mask at channel 0 and crossing\n", + " target at channel 1.\n", + "\n", + " Raises\n", + " ------\n", + " TypeError\n", + " If the DeepTrack pipeline does not return ``(image, target)``.\n", + "\n", + " \"\"\"\n", + "\n", + " self.pipeline.update()\n", + " result = self.pipeline(self.source[index])\n", + "\n", + " if not isinstance(result, (tuple, list)) or len(result) != 2:\n", + " raise TypeError(\"The pipeline must return (image, target).\")\n", + "\n", + " image, target = result\n", + "\n", + " return self._to_tensor(image), self._to_tensor(target)\n", + "\n", + "\n", + "train_dataset = DeepTrackSourceDataset(\n", + " train_source,\n", + " TARGET_SIZE,\n", + " augment=True,\n", + " normalize_image=False,\n", + ")\n", + "\n", + "val_dataset = DeepTrackSourceDataset(\n", + " val_source,\n", + " TARGET_SIZE,\n", + " augment=False,\n", + " normalize_image=False,\n", + ")\n", + "\n", + "train_loader = dl.DataLoader(\n", + " train_dataset,\n", + " batch_size=int(TRAIN_CFG['batch_size']),\n", + " shuffle=True,\n", + " num_workers=int(TRAIN_CFG['num_workers']),\n", + " pin_memory=torch.cuda.is_available(),\n", + " persistent_workers=int(TRAIN_CFG['num_workers']) > 0,\n", + ")\n", + "\n", + "val_loader = dl.DataLoader(\n", + " val_dataset,\n", + " batch_size=int(TRAIN_CFG['batch_size']),\n", + " shuffle=False,\n", + " num_workers=int(TRAIN_CFG['num_workers']),\n", + " pin_memory=torch.cuda.is_available(),\n", + " persistent_workers=int(TRAIN_CFG['num_workers']) > 0,\n", + ")\n", + "\n", + "image_batch, target_batch = next(iter(train_loader))\n", + "print('image batch:', tuple(image_batch.shape), image_batch.dtype)\n", + "print('target batch:', tuple(target_batch.shape), target_batch.dtype)\n", + "print('target channels: DNA = 0, crossings = 1')" + ] + }, + { + "cell_type": "markdown", + "id": "5G7C_IGGhLPM", + "metadata": { + "id": "5G7C_IGGhLPM" + }, + "source": [ + "# 18. Deeplay U-Net and multitask loss\n", + "\n", + "The U-Net has two output heads, one for the crossings and one for the DNA. Channel 0 is the DNA logit\n", + "map and channel 1 is the crossing logit map. DNA uses BCE-Dice loss;\n", + "crossings use a focal BCE loss." + ] + }, + { + "cell_type": "code", + "execution_count": 255, + "id": "ajbx1-S2hLPN", + "metadata": { + "id": "ajbx1-S2hLPN" + }, + "outputs": [], + "source": [ + "def dice_loss_from_logits(\n", + " logits: torch.Tensor,\n", + " target: torch.Tensor,\n", + " smooth: float = 1.0,\n", + ") -> torch.Tensor:\n", + " \"\"\"Return soft Dice loss for binary segmentation logits.\"\"\"\n", + "\n", + " prob = torch.sigmoid(logits)\n", + " dims = tuple(range(1, prob.ndim))\n", + "\n", + " inter = torch.sum(prob * target, dim=dims)\n", + " denom = torch.sum(prob, dim=dims) + torch.sum(target, dim=dims)\n", + " dice = (2.0 * inter + smooth) / (denom + smooth)\n", + "\n", + " return 1.0 - dice.mean()\n", + "\n", + "\n", + "def focal_bce_loss_from_logits(\n", + " logits: torch.Tensor,\n", + " target: torch.Tensor,\n", + " gamma: float = 2.0,\n", + " pos_weight: float = 50.0,\n", + ") -> torch.Tensor:\n", + " \"\"\"Return focal BCE loss for sparse crossing heatmaps.\"\"\"\n", + "\n", + " bce = F.binary_cross_entropy_with_logits(\n", + " logits,\n", + " target,\n", + " reduction=\"none\",\n", + " )\n", + "\n", + " prob = torch.sigmoid(logits)\n", + " pt = prob * target + (1.0 - prob) * (1.0 - target)\n", + "\n", + " focal_weight = (1.0 - pt).pow(gamma)\n", + " class_weight = 1.0 + float(pos_weight) * target\n", + "\n", + " return torch.mean(class_weight * focal_weight * bce)\n", + "\n", + "def masked_mean(\n", + " value: torch.Tensor,\n", + " mask: torch.Tensor,\n", + " eps: float = 1e-6,\n", + ") -> torch.Tensor:\n", + " \"\"\"Return mean of value over mask, avoiding dilution by zero pixels.\"\"\"\n", + "\n", + " weighted_sum = torch.sum(value * mask)\n", + " normalizer = torch.sum(mask) + eps\n", + "\n", + " return weighted_sum / normalizer\n", + "\n", + "\n", + "class DNACrossingLoss(nn.Module):\n", + " \"\"\"Combined DNA segmentation loss and crossing heatmap loss.\n", + "\n", + " The prediction tensor must have two channels:\n", + "\n", + " - channel 0: DNA logits\n", + " - channel 1: crossing logits\n", + "\n", + " The target tensor must have two matching channels:\n", + "\n", + " - channel 0: binary DNA mask\n", + " - channel 1: crossing heatmap or crossing mask\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " dna_pos_weight: float = 1.0,\n", + " dna_loss_weight: float = 1.0,\n", + " cross_loss_weight: float = 0.25,\n", + " cross_pos_weight: float = 50.0,\n", + " cross_false_positive_weight: float = 0.5,\n", + " background_false_positive_weight: float = 0.02,\n", + " dice_smooth: float = 1.0,\n", + " ):\n", + " super().__init__()\n", + "\n", + " self.dna_loss_weight = float(dna_loss_weight)\n", + " self.cross_loss_weight = float(cross_loss_weight)\n", + " self.cross_pos_weight = float(cross_pos_weight)\n", + " self.cross_false_positive_weight = float(\n", + " cross_false_positive_weight\n", + " )\n", + " self.background_false_positive_weight = float(\n", + " background_false_positive_weight\n", + " )\n", + " self.dice_smooth = float(dice_smooth)\n", + "\n", + " self.register_buffer(\n", + " \"dna_pos_weight\",\n", + " torch.tensor(float(dna_pos_weight)),\n", + " )\n", + "\n", + " def forward(\n", + " self,\n", + " pred: torch.Tensor,\n", + " target: torch.Tensor,\n", + " ) -> torch.Tensor:\n", + " \"\"\"Return the weighted DNA and crossing losses.\"\"\"\n", + "\n", + " dna_logits = pred[:, 0:1]\n", + " cross_logits = pred[:, 1:2]\n", + "\n", + " target_dna = target[:, 0:1]\n", + " target_cross = target[:, 1:2]\n", + "\n", + " dna_bce = F.binary_cross_entropy_with_logits(\n", + " dna_logits,\n", + " target_dna,\n", + " pos_weight=self.dna_pos_weight.to(pred.device),\n", + " )\n", + " dna_dice = dice_loss_from_logits(\n", + " dna_logits,\n", + " target_dna,\n", + " smooth=self.dice_smooth,\n", + " )\n", + " dna_loss = 0.5 * dna_bce + 0.5 * dna_dice\n", + "\n", + " cross_loss = focal_bce_loss_from_logits(\n", + " cross_logits,\n", + " target_cross,\n", + " gamma=2.0,\n", + " pos_weight=self.cross_pos_weight,\n", + " )\n", + "\n", + " cross_prob = torch.sigmoid(cross_logits)\n", + " cross_region = (target_cross > 0.05).float()\n", + "\n", + " # Strongly suppress crossing predictions on ordinary DNA pixels.\n", + " non_crossing_dna = target_dna * (1.0 - cross_region)\n", + " dna_false_positive_loss = masked_mean(\n", + " torch.square(cross_prob),\n", + " non_crossing_dna,\n", + " )\n", + "\n", + " # Weakly suppress crossing predictions away from true crossings.\n", + " background_region = 1.0 - cross_region\n", + " background_false_positive_loss = masked_mean(\n", + " torch.square(cross_prob),\n", + " background_region,\n", + " )\n", + "\n", + " cross_loss = (\n", + " cross_loss\n", + " + self.cross_false_positive_weight * dna_false_positive_loss\n", + " + self.background_false_positive_weight\n", + " * background_false_positive_loss\n", + " )\n", + "\n", + " return (\n", + " self.dna_loss_weight * dna_loss\n", + " + self.cross_loss_weight * cross_loss\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 256, + "id": "HSGpfLYkOsSP", + "metadata": { + "id": "HSGpfLYkOsSP" + }, + "outputs": [], + "source": [ + "import torch\n", + "import torchmetrics\n", + "\n", + "\n", + "class DNADiceMetric(torchmetrics.Metric):\n", + " \"\"\"Compute DNA Dice score for the DNA output channel.\n", + "\n", + " This metric expects the model prediction to have two channels, where\n", + " channel 0 contains DNA logits. The target is also expected to have two\n", + " channels, where channel 0 contains the DNA mask.\n", + " \"\"\"\n", + "\n", + " full_state_update = False\n", + "\n", + " def __init__(self, smooth: float = 1.0):\n", + " \"\"\"Initialize the accumulated Dice statistics.\"\"\"\n", + " super().__init__()\n", + " self.smooth = float(smooth)\n", + "\n", + " self.add_state(\n", + " \"intersection\",\n", + " default=torch.tensor(0.0),\n", + " dist_reduce_fx=\"sum\",\n", + " )\n", + " self.add_state(\n", + " \"pred_sum\",\n", + " default=torch.tensor(0.0),\n", + " dist_reduce_fx=\"sum\",\n", + " )\n", + " self.add_state(\n", + " \"target_sum\",\n", + " default=torch.tensor(0.0),\n", + " dist_reduce_fx=\"sum\",\n", + " )\n", + "\n", + " def update(\n", + " self,\n", + " preds: torch.Tensor,\n", + " target: torch.Tensor,\n", + " ) -> None:\n", + " \"\"\"Update Dice statistics for one batch.\"\"\"\n", + " pred_dna = torch.sigmoid(preds[:, 0:1])\n", + " pred_dna = (pred_dna > 0.5).float()\n", + " target_dna = target[:, 0:1].float()\n", + "\n", + " self.intersection += torch.sum(pred_dna * target_dna)\n", + " self.pred_sum += torch.sum(pred_dna)\n", + " self.target_sum += torch.sum(target_dna)\n", + "\n", + " def compute(self) -> torch.Tensor:\n", + " \"\"\"Return the accumulated DNA Dice score.\"\"\"\n", + " numerator = 2.0 * self.intersection + self.smooth\n", + " denominator = self.pred_sum + self.target_sum + self.smooth\n", + "\n", + " return numerator / denominator" + ] + }, + { + "cell_type": "markdown", + "id": "aKsZcCVFEQud", + "metadata": { + "id": "aKsZcCVFEQud" + }, + "source": [ + "...and now we build the U-net..." + ] + }, + { + "cell_type": "code", + "execution_count": 257, + "id": "af9426d7-fe67-4249-ad37-7c52b7e81d06", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Optional, Sequence\n", + "\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import deeplay as dl\n", + "\n", + "\n", + "def _valid_group_count(\n", + " num_channels: int,\n", + " max_groups: int = 8,\n", + ") -> int:\n", + " \"\"\"Return a valid GroupNorm group count for the channel count.\"\"\"\n", + "\n", + " num_channels = int(num_channels)\n", + " max_groups = int(max_groups)\n", + "\n", + " for groups in (max_groups, 8, 4, 2, 1):\n", + " if groups <= num_channels and num_channels % groups == 0:\n", + " return groups\n", + "\n", + " return 1\n", + "\n", + "\n", + "class ResidualBlock(nn.Module):\n", + " \"\"\"Two-convolution residual block for U-Net encoder/decoder stages.\"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " in_channels: int,\n", + " out_channels: int,\n", + " dropout: float = 0.0,\n", + " norm_groups: int = 8,\n", + " ):\n", + " super().__init__()\n", + "\n", + " in_channels = int(in_channels)\n", + " out_channels = int(out_channels)\n", + " groups = _valid_group_count(out_channels, norm_groups)\n", + "\n", + " self.main = nn.Sequential(\n", + " nn.Conv2d(\n", + " in_channels,\n", + " out_channels,\n", + " kernel_size=3,\n", + " padding=1,\n", + " bias=False,\n", + " ),\n", + " nn.GroupNorm(groups, out_channels),\n", + " nn.ReLU(inplace=True),\n", + " nn.Dropout2d(dropout) if dropout > 0.0 else nn.Identity(),\n", + " nn.Conv2d(\n", + " out_channels,\n", + " out_channels,\n", + " kernel_size=3,\n", + " padding=1,\n", + " bias=False,\n", + " ),\n", + " nn.GroupNorm(groups, out_channels),\n", + " )\n", + "\n", + " # Use a 1 x 1 projection only when the channel count changes.\n", + " self.shortcut = (\n", + " nn.Identity()\n", + " if in_channels == out_channels\n", + " else nn.Conv2d(\n", + " in_channels,\n", + " out_channels,\n", + " kernel_size=1,\n", + " bias=False,\n", + " )\n", + " )\n", + "\n", + " def forward(self, x: torch.Tensor) -> torch.Tensor:\n", + " \"\"\"Apply the residual block.\"\"\"\n", + "\n", + " return F.relu(self.main(x) + self.shortcut(x), inplace=True)\n", + "\n", + "\n", + "class UpBlock(nn.Module):\n", + " \"\"\"Upsample decoder features and merge them with an encoder skip.\"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " in_channels: int,\n", + " skip_channels: int,\n", + " out_channels: int,\n", + " dropout: float = 0.0,\n", + " norm_groups: int = 8,\n", + " ):\n", + " super().__init__()\n", + "\n", + " self.reduce_channels = nn.Conv2d(\n", + " int(in_channels),\n", + " int(out_channels),\n", + " kernel_size=1,\n", + " )\n", + "\n", + " self.block = ResidualBlock(\n", + " in_channels=int(out_channels) + int(skip_channels),\n", + " out_channels=int(out_channels),\n", + " dropout=dropout,\n", + " norm_groups=norm_groups,\n", + " )\n", + "\n", + " def forward(\n", + " self,\n", + " x: torch.Tensor,\n", + " skip: torch.Tensor,\n", + " ) -> torch.Tensor:\n", + " \"\"\"Upsample, concatenate the skip connection, and refine.\"\"\"\n", + "\n", + " x = F.interpolate(\n", + " x,\n", + " size=skip.shape[-2:],\n", + " mode=\"bilinear\",\n", + " align_corners=False,\n", + " )\n", + " x = self.reduce_channels(x)\n", + " x = torch.cat([x, skip], dim=1)\n", + "\n", + " return self.block(x)\n", + "\n", + "\n", + "class ResUNetTwoHeads(dl.DeeplayModule):\n", + " \"\"\"Residual U-Net with separate DNA and crossing output heads.\n", + "\n", + " The model returns a tensor with shape ``(B, 2, H, W)``.\n", + "\n", + " Output channels:\n", + " channel 0: DNA logits\n", + " channel 1: crossing logits\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " in_channels: int = 1,\n", + " channels: Optional[Sequence[int]] = None,\n", + " dropout: float = 0.05,\n", + " norm_groups: int = 8,\n", + " ):\n", + " super().__init__()\n", + "\n", + " if channels is None:\n", + " channels = (16, 32, 64, 128)\n", + "\n", + " channels = [int(channel) for channel in channels]\n", + "\n", + " if len(channels) < 2:\n", + " raise ValueError(\"channels must contain at least two values.\")\n", + "\n", + " self.pool = nn.MaxPool2d(kernel_size=2, stride=2)\n", + "\n", + " self.encoders = nn.ModuleList()\n", + " previous_channels = int(in_channels)\n", + "\n", + " for out_channels in channels:\n", + " self.encoders.append(\n", + " ResidualBlock(\n", + " in_channels=previous_channels,\n", + " out_channels=out_channels,\n", + " dropout=dropout,\n", + " norm_groups=norm_groups,\n", + " )\n", + " )\n", + " previous_channels = out_channels\n", + "\n", + " bottleneck_channels = channels[-1] * 2\n", + "\n", + " self.bottleneck = ResidualBlock(\n", + " in_channels=channels[-1],\n", + " out_channels=bottleneck_channels,\n", + " dropout=dropout,\n", + " norm_groups=norm_groups,\n", + " )\n", + "\n", + " self.decoders = nn.ModuleList()\n", + " decoder_channels = bottleneck_channels\n", + "\n", + " for skip_channels in reversed(channels):\n", + " self.decoders.append(\n", + " UpBlock(\n", + " in_channels=decoder_channels,\n", + " skip_channels=skip_channels,\n", + " out_channels=skip_channels,\n", + " dropout=dropout,\n", + " norm_groups=norm_groups,\n", + " )\n", + " )\n", + " decoder_channels = skip_channels\n", + "\n", + " final_channels = channels[0]\n", + "\n", + " # Separate heads let DNA and crossing predictions specialize.\n", + " self.dna_head = self._make_head(final_channels, norm_groups)\n", + " self.crossing_head = self._make_head(final_channels, norm_groups)\n", + "\n", + " @staticmethod\n", + " def _make_head(\n", + " in_channels: int,\n", + " norm_groups: int,\n", + " ) -> nn.Sequential:\n", + " \"\"\"Create one single-channel prediction head.\"\"\"\n", + "\n", + " groups = _valid_group_count(in_channels, norm_groups)\n", + "\n", + " return nn.Sequential(\n", + " nn.Conv2d(\n", + " in_channels,\n", + " in_channels,\n", + " kernel_size=3,\n", + " padding=1,\n", + " bias=False,\n", + " ),\n", + " nn.GroupNorm(groups, in_channels),\n", + " nn.ReLU(inplace=True),\n", + " nn.Conv2d(in_channels, 1, kernel_size=1),\n", + " )\n", + "\n", + " def forward(self, x: torch.Tensor) -> torch.Tensor:\n", + " \"\"\"Run the residual U-Net forward pass.\"\"\"\n", + "\n", + " skips = []\n", + "\n", + " # Save encoder features before each downsampling step.\n", + " for level, encoder in enumerate(self.encoders):\n", + " if level > 0:\n", + " x = self.pool(x)\n", + "\n", + " x = encoder(x)\n", + " skips.append(x)\n", + "\n", + " # The bottleneck operates at the lowest spatial resolution.\n", + " x = self.pool(x)\n", + " x = self.bottleneck(x)\n", + "\n", + " for decoder, skip in zip(self.decoders, reversed(skips)):\n", + " x = decoder(x, skip)\n", + "\n", + " dna_logits = self.dna_head(x)\n", + " crossing_logits = self.crossing_head(x)\n", + "\n", + " return torch.cat([dna_logits, crossing_logits], dim=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 258, + "id": "MAhbZR8VhLPN", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "MAhbZR8VhLPN", + "outputId": "897528a3-c438-4440-abbc-9c0f607aa476" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regressor(\n", + " (loss): DNACrossingLoss()\n", + " (optimizer): Adam[Adam](lr=0.0003)\n", + " (train_metrics): MetricCollection(\n", + " (DNADiceMetric): DNADiceMetric(),\n", + " prefix=train\n", + " )\n", + " (val_metrics): MetricCollection(\n", + " (DNADiceMetric): DNADiceMetric(),\n", + " prefix=val\n", + " )\n", + " (test_metrics): MetricCollection(\n", + " (DNADiceMetric): DNADiceMetric(),\n", + " prefix=test\n", + " )\n", + " (model): ResUNetTwoHeads(\n", + " (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (encoders): ModuleList(\n", + " (0): ResidualBlock(\n", + " (main): Sequential(\n", + " (0): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (1): GroupNorm(8, 32, eps=1e-05, affine=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): Dropout2d(p=0.05, inplace=False)\n", + " (4): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (5): GroupNorm(8, 32, eps=1e-05, affine=True)\n", + " )\n", + " (shortcut): Conv2d(1, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (1): ResidualBlock(\n", + " (main): Sequential(\n", + " (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (1): GroupNorm(8, 64, eps=1e-05, affine=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): Dropout2d(p=0.05, inplace=False)\n", + " (4): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (5): GroupNorm(8, 64, eps=1e-05, affine=True)\n", + " )\n", + " (shortcut): Conv2d(32, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (2): ResidualBlock(\n", + " (main): Sequential(\n", + " (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (1): GroupNorm(8, 128, eps=1e-05, affine=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): Dropout2d(p=0.05, inplace=False)\n", + " (4): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (5): GroupNorm(8, 128, eps=1e-05, affine=True)\n", + " )\n", + " (shortcut): Conv2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (3): ResidualBlock(\n", + " (main): Sequential(\n", + " (0): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (1): GroupNorm(8, 256, eps=1e-05, affine=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): Dropout2d(p=0.05, inplace=False)\n", + " (4): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (5): GroupNorm(8, 256, eps=1e-05, affine=True)\n", + " )\n", + " (shortcut): Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " )\n", + " (bottleneck): ResidualBlock(\n", + " (main): Sequential(\n", + " (0): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (1): GroupNorm(8, 512, eps=1e-05, affine=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): Dropout2d(p=0.05, inplace=False)\n", + " (4): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (5): GroupNorm(8, 512, eps=1e-05, affine=True)\n", + " )\n", + " (shortcut): Conv2d(256, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (decoders): ModuleList(\n", + " (0): UpBlock(\n", + " (reduce_channels): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " (block): ResidualBlock(\n", + " (main): Sequential(\n", + " (0): Conv2d(512, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (1): GroupNorm(8, 256, eps=1e-05, affine=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): Dropout2d(p=0.05, inplace=False)\n", + " (4): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (5): GroupNorm(8, 256, eps=1e-05, affine=True)\n", + " )\n", + " (shortcut): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " )\n", + " (1): UpBlock(\n", + " (reduce_channels): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))\n", + " (block): ResidualBlock(\n", + " (main): Sequential(\n", + " (0): Conv2d(256, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (1): GroupNorm(8, 128, eps=1e-05, affine=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): Dropout2d(p=0.05, inplace=False)\n", + " (4): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (5): GroupNorm(8, 128, eps=1e-05, affine=True)\n", + " )\n", + " (shortcut): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " )\n", + " (2): UpBlock(\n", + " (reduce_channels): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1))\n", + " (block): ResidualBlock(\n", + " (main): Sequential(\n", + " (0): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (1): GroupNorm(8, 64, eps=1e-05, affine=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): Dropout2d(p=0.05, inplace=False)\n", + " (4): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (5): GroupNorm(8, 64, eps=1e-05, affine=True)\n", + " )\n", + " (shortcut): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " )\n", + " (3): UpBlock(\n", + " (reduce_channels): Conv2d(64, 32, kernel_size=(1, 1), stride=(1, 1))\n", + " (block): ResidualBlock(\n", + " (main): Sequential(\n", + " (0): Conv2d(64, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (1): GroupNorm(8, 32, eps=1e-05, affine=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): Dropout2d(p=0.05, inplace=False)\n", + " (4): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (5): GroupNorm(8, 32, eps=1e-05, affine=True)\n", + " )\n", + " (shortcut): Conv2d(64, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " )\n", + " )\n", + " (dna_head): Sequential(\n", + " (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (1): GroupNorm(8, 32, eps=1e-05, affine=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): Conv2d(32, 1, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " (crossing_head): Sequential(\n", + " (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (1): GroupNorm(8, 32, eps=1e-05, affine=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): Conv2d(32, 1, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " )\n", + ")\n" + ] + } + ], + "source": [ + "unet = ResUNetTwoHeads(\n", + " in_channels=int(MODEL_CFG[\"in_channels\"]),\n", + " channels=list(MODEL_CFG[\"channels\"]),\n", + " dropout=0.05,\n", + " norm_groups=8,\n", + ")\n", + "\n", + "loss_fn = DNACrossingLoss(\n", + " dna_pos_weight=float(TRAIN_CFG[\"dna_pos_weight\"]),\n", + " dna_loss_weight=float(TRAIN_CFG[\"dna_loss_weight\"]),\n", + " cross_loss_weight=float(TRAIN_CFG[\"cross_loss_weight\"]),\n", + " cross_pos_weight=float(TRAIN_CFG[\"cross_pos_weight\"]),\n", + " cross_false_positive_weight=float(\n", + " TRAIN_CFG[\"cross_false_positive_weight\"]\n", + " ),\n", + " background_false_positive_weight=float(\n", + " TRAIN_CFG[\"background_false_positive_weight\"]\n", + " ),\n", + " dice_smooth=float(TRAIN_CFG[\"dice_smooth\"]),\n", + ")\n", + "\n", + "dna_dice_metric = DNADiceMetric(\n", + " smooth=float(TRAIN_CFG[\"dice_smooth\"]),\n", + ")\n", + "\n", + "unet_template = dl.Regressor(\n", + " model=unet,\n", + " loss=loss_fn,\n", + " metrics=[dna_dice_metric],\n", + " optimizer=dl.Adam(lr=float(TRAIN_CFG[\"lr\"])),\n", + ")\n", + "\n", + "unet_app = unet_template.create()\n", + "print(unet_app)" + ] + }, + { + "cell_type": "markdown", + "id": "ZJ3x8tyFhLPN", + "metadata": { + "id": "ZJ3x8tyFhLPN" + }, + "source": [ + "### Train and validate" + ] + }, + { + "cell_type": "code", + "execution_count": 259, + "id": "WDMgtIjNhLPN", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 420, + "referenced_widgets": [ + "8b28746752804efb9514a943d1eaaa40", + "719c2567f6c143f2bd88659fdbc158fb", + "4d504ee7c6074c64960523a855043fbc", + "b0a7821cc80b4d3085d0e3ed5722edd5", + "a90137b5afbb4831a319bd707ae66e55", + "7e8401965c3e4bce8c7c03f927e647b7", + "2b88126853b94cf085854107c124e754", + "ad94f07de5fd480c95d444bf89488537", + "fa210271474f4e82bb4d087e1ffeee4f", + "3a5610b41c5f49d78c2e89e23006cfd9", + "b9787a3252ca42b2a28072694afa7def", + "6daeec99a0ec4247b33fcc5424cdf2b1", + "3f8d2f2e30e54ea9ac57deca09cb34c8", + "084e9fa8a9924883ab4de7f6ff398d69", + "2ce720e250ef4bcc986904febc125b48", + "6a703a473224472f9f300236fc25bbe1", + "2902a8dadce1454491f29a01b6655cd3", + "3515df2d16e14a0284f605d63a48240e", + "140d409c39384bd8a39f55c3e7964c15", + "9a367b91d3fb40699363c94d40a21c7c", + "fc0b3426a46844028503ab46da1230fe", + "48f5b787955e41189e698f9f842d0523", + "c88525bd6bf54f718d16f5e7b2c8a438", + "043020ee46b04b0e849aa065eb1688e6", + "51a977e26e3246c0bb2f6e079a06a7bc", + "d4614ca1e2ee41e3a78be809c911e5a7", + "56399d46ad8b44ed8ed0adf329893522", + "7c8de7d0ad144b64bbfff2d0851c9ff2", + "5a20ac379047420483e2e3c281846da8", + "174d67b232ac40d695cb15665959ac0c", + "8a991636ec0d4514973402ce7942f200", + "e8f6d51de5214b58938e06faacf9e90f", + "c76e8e95ff844324b72e1ae2a040b673", + "3cc511d5ba384c10aa8d0d285ae9bc73", + "44500e4704f14a2ba6523013f2f237cb", + "cd2246e275ab4283aea5036a3c083cc3", + "1ba0dee7653247c8b6008c8c60dd40bd", + "fe23ff3e550a48de82471507e913f733", + "44930c49f41248f38f21e9d23941a1b3", + "4140dfc3649f489dbdb41c85525ea599", + "5d738cc2fe5447cb89f343a31554e050", + "daaac23228ea45da98b5c3819047daf2", + "3b4b83b841ab45bb9a19e08f52bfc887", + "6f6933d25b4147a288c1142f8aa49e24", + "4f64f33ec76545669aad6cad0532bf52", + "fe72db6203cc472695e2217021d84b33", + "a4a766bb527240aca3846cb63d9f1e1b", + "682e08c8af3247b8b01a31a113920e4f", + "904dd3a3be60473c91575ed0105bec04", + "966280e648174531853430b876c96b3e", + "80b7e2aa713a45ca9c2bf8eae7d6bb4d", + "6f5f7d72f10c42f2a13a4e330cd1d96d", + "c65cc31b212940c09f11ceb11c222ef4", + "c33091d26af94d4f849426d89604efc6", + "bd210a7aa7724c048560040debfbd7f6", + "07fd460123374011924050488957dfb9", + "fdd0ef85a11e431c8b9584622aa675f0", + "e2f90203e06442c88ac36903ea85f8e7", + "719b5325829f44caa738198d8d8919e2", + "851f40556b6545f1b2e8b2c49d1f3a24", + "3389a58f19334452a8a25dbe5e19f09a", + "afbf370d7070420baad9e7ce8b643456", + "962668142d9b497db0704cbc10129a80", + "3c85353efe9b47888787857596cb1741", + "2e608130a04c4799993b4ec2f0027f79", + "2c50e0b4586140f89b5c932f0924d24a", + "425cdf165e3549f592d2c869829a5cfc", + "d911964788894e79855e0ae47953103a", + "bb4da1ba8c2c47e084597c70e2441a44", + "4d3fad88182241c99d755adf8e5bbb77", + "efa4351f438740ebb3b555206fe96b6e", + "66a4a0681ee44eff8f045b7a385cd1a2", + "6a5a24e536314b55952f3ee2d8719970", + "4a405964924f4527bc988f1679002ea2", + "b8ff4c15bd8b404d8eba17d813f5a423", + "8e6caa11df7d40c880506ce1587d3080", + "03d29d4401344338a1bc1e840b8a8208", + "40ce8ac2ba224beb9d1cebb9295eae2c", + "b5ae1f24f1144a99bbae2c07ab050537", + "2c4a4a15fc154209857e5bc221d4a60b", + "7b6afd64da3f49c48f76feb8b75e54dd", + "604c401384d042eebd72651c36e9b3e5", + "cb153aa133b14ab08dfa44caeeb6b81e", + "1119633b9b7f45bcb9274237898ae999", + "8e84599c746a4d149d3f8930f2fab49d", + "9d7149c5a5174b5da388a5898036e8af", + "d93a2657edec4e23a50f067465192ee6", + "561247266aca4a06a29ca8d77d5390f1", + "23d930a463d04ebbac79f8ada451c1af", + "945010c321a84e41828d564ccd6cab17", + "f65b58b468a442fa9eeef48cccb9164f", + "2fa51f1fbb8b41359089e64ea3d9e709", + "84d2ca2125194162937cd60d202efee3", + "58034176a80143809a8dfc91a9a3aff3", + "556e1708cb714b7ca1f24dbcc30845cb", + "cb3e60255a18440b8bd26c6682520e63", + "0b1024f20aaa459aabd611e80ae46e53", + "4671ae95c7024ac9aef90bde31b1cd5a", + "54a4b9d97f1f4908871c6410b0372c9d", + "ebd8e5f5fc36423e854f3eb3d01a3ccb", + "4526a155d76542528b553180e2c9f107", + "43ad8d40f2104267a64d02c8a4735f42", + "f0d35a683ffe4f61a9ed609a837b0cc7", + "201b24c9f69c4af18145260bb4ecb762", + "81671ac2f73b48669e505f454b013dca", + "a289a2fa75f04aae936662ccd032d70f", + "3250e51e0ed34ad9a8a81354466952bd", + "709b15f575e2439b914968dce170619a", + "e3308390869847b1a8c4123b5350f9d7", + "17bdd1be5491412cacbecb7feeae2fc7", + "678a690a7ede408fbd504364e0515db1", + "705032b0be3741eb8d9f4cc9d3842feb", + "5729ea76ec2b4c9eb3f5143f3e5b0a60", + "5c6215db50ab462388024533bc764d6c", + "475556f9d2db4569b985192b4648a9bb", + "138d51e2eee64063b8347d75eb3002e5", + "385582d247594701bf07ea19abcc6961", + "db7f36c1229c472bbfca23cfc260f4c5", + "77babc7cce66414b87aa437610eb4bd5", + "b6f83849585749c9851b2eb021d99f97", + "2f65e0c84ad0488589d9099d8857e813", + "827ab09eb5244faaa2bb7737bc38a662", + "0d0222a098a24c4db6e99d2e3f0921ad", + "59e61b3b77174b06a86e04d5ebda5703", + "8874086714df499886c05cfaf1202ff1", + "215a7a11baf44b5782096bc13d88a0be", + "7501155baee5472f9140ac1e04845f75", + "33c6b24328c341e190273d1ab5d3917a", + "8a3f0120a932480fabd5df4bab19b4ee", + "bfe5ecfb0f4c402ca61d4c401882c29f", + "d8dea74096e64878b237c0a851aac991", + "e34bdd70106343a5b8612b488b0113f6", + "1c9744b2ed434eedba77eb04cabdf204", + "61c1424c837a411d91e1e361e2f663fb", + "5d24e35625b1440fb3e0254d16762b22", + "995eb88c1ce5422b83ec25f99a059bb0", + "3e98332b532745d3bbcac8801aae2a31", + "4cb23d2da234483fab7b0d292aae77d6", + "cfddec8a651f495397214b49f9b8091d", + "80f20c8f2c1948c69cd779e36f7066c7", + "5ae95da99ca04dd899c2e10cfcb1a4b7", + "308d296e4c784d5e88bf05985a0a6273", + "996b3a00f07045c48d80011f2f6bf295", + "38a1154b2af840c2bfa56f98637ee08d", + "56e7ad0645874b6697ee7d6058041638", + "8ce63facf77441cf8015139500564c5d", + "c740afa60993457d959de43a861e200d", + "f3ab972f1ab14fd69d87e7a9af800aaf", + "917afa78da954d1e8ad09dd4cf9f4202", + "0ae94f04037447acb216044112f9175b", + "43989ff4ef934577b920e58f7458cc0a", + "e813e4725c4a43adba6363b551246f61", + "84deef98024b48efb3f18fae1ee3dffc", + "a1b8f183134e41c3969882b651876c05", + "7861c5c2fdc54fcd8f3cfb26be5f4dc5", + "47aded72d1e2424f97dc3426fbff540f", + "ebbf3193c2ea4b7d98d8504af04bb7e1", + "c9899780726f453b8ef79792b92576cc", + "6e2e3c6c871342c883141e0314353e37", + "2b2610ec8b884911a15455ebb9f8852b", + "5429aadaaaaa4767942be28932e6e09a", + "d61e750471554974ae9b07a81dce6932", + "7d6da8d8ded148e7958e1b747424828a", + "efa1c19e95504fbfb3130ce5d2f9e06e", + "74f2bc8b9aee4fc9986ed0e6d833bab3", + "94de6e1f0dc54520b8bf96bec4599f9a", + "6bfbb82616da41e6aa398500f81eb7b5", + "6390e224619346a8af81a12030c7fb38", + "0f6cde3fd35f4bf7ad1e8b22a2915a29", + "277bc910427c41c09786efadfb15e973", + "030b37cea4ba414db5fae6384ed6cdb6", + "f73f08cd498a47eaa01b6ee3e0a9d288", + "72299ab304f54db1a02a56f0d4c0ec54", + "aa0d6cf2f28040c19305a9704740ec23", + "c3ae2ada559f4a77834b47afeb954e2e", + "1ff6d20727704f89a15e7f62263b7c03", + "f12bed710be1411f8e30968f4e09554e", + "e6cf9c9bda7b4d37a0ea40d0565bdc25", + "7cb62ceb722f4d38b9c5d80b32b0841a", + "9c0cb0386434437681770e99b0db0744", + "413006fb9d2e453abf39cdd4b91caa75", + "d4ca8a1f229148a880d420776312aff2", + "7eaa8bd25f384c9a8ba7fb6faed6b3f7", + "ec1864db512149518a1b0cbbbab057d6", + "bbfe385d70f84c3fa7c22e04a4faa8a3", + "6a9cab5ce8ff43b3a57c47931d4c1cc8", + "bf19184bcfd74fd6a01f0e791d4b1bb9", + "ffae1f6825c045178ae33dea1d805c87", + "fb12c181ee7d42c7aa4256347200bea4", + "bc93eb10d7f44b559d17c6b5c6cb93b7", + "209c4f3f80e14a969afb2b32c7216dbd", + "2345ab7c9cfb4dc295f34c54579408fb", + "c67eb73d43c449f2801750558f4a521d", + "c0c48b257aa04dd4883d496f59eb1d82", + "1088c60e62f64798b702028799231729", + "6b89e0a40f934cd78aa670de2bbc7158", + "12a635899c1643788e566ba87ab1723c", + "9504247d6ca649aea2ef4ad828f523a6", + "72823355de9044eba020e56ffe2d3865", + "87dd9bcece474721b57d651815d4115a", + "80202dea9db64ae7987c220a85a7dcac", + "6178e85c32c64115bd3105cd74efed18", + "0eaa81e3e1d443c387792ee6e64fd1b6", + "5c49200354514c20bdb71fedbcf634a2", + "9546adf443cb47cea6d50a2c4f24fd85", + "ce568ae8b1bd4bc28cea074e0a295ef0", + "d2232ad66e614f79aa31dacb583eac7e", + "4fb03babee474f98bc3f153b930c3973", + "22ad0c58d4a94b469e15b425c20edb60", + "671faaa6260e4b6687d39e69951d7764", + "37b3cad147f74c4397a16ca6883ba98a", + "f977f92cd00040b79d1370265c355470", + "7ee7fbcfa28f4708b85d4721945a34c6", + "2426adb29a43459895b1f5192654b6ec", + "ba5d1cdcc089456b81b50d8e9c033bfa", + "4a34d533b9374b60aec1d1b6e8935014", + "d794297461194c3d98cbf0f27d30b67a", + "27807cb739b249a59a6e0d9d317414df", + "0b0b8dfdf0054425b83e8a4994acc8fc", + "7ec6252e85764215b7b94d323aeba6d6", + "67da59c080324e948eeb07890d5ee9da", + "73a668df55a54615ba5bffc804be35af", + "e80004eab2b54b4eafcfab7c2dec94d9", + "2701cb8cf0b64ae0b15efe9c0e32dd01", + "bb444ac91bbf4b91883b5ccd40b6bd41", + "9cce801e24c147cea6eb4861b5a55987", + "885eba97a8bd4006ae9cc9994724c6a8", + "1f272fa725454bb3bf529bdf2604eb12", + "279a78ac51154592a3d288be64dc843f", + "2bc4378549914bd4a48aaf0a677ddc41", + "8cc548cea0c247d4ae5ab1eeed9cc475", + "4190b291524948279b199476f5533730", + "6438832fe5474201965419106035e40e", + "eb045b2ed03c4f31b6e30f8c54f5e34a", + "14dbde6953364c5c87d9469c49959066", + "30eef8822a3645bda76c1de7866f2d7a", + "3314d1f00dd74034bc28143b99bef726", + "7e095acd45294cd499418a6dc525ac28", + "4e0c287d06814086b4c1b478fb11dfe5", + "451d8508824949d0ae06c2be42504f7b", + "3de0b3794ad54c45b7c019cfd285a95e", + "e2362e5efae7467b8e58786955739072", + "d2b1934184984f6da6e2a9f0cc091e2e", + "f0c011f3be21460f8b128ff280d68808", + "712feb908f5045e39b75f7123bb7dbf6", + "a1478fa6b5ce4aa9bd0ccee4c50602f5", + "7a37a6630f874ef1af76b2c89f6fe269", + "5f8819ebd06e4a3f8dab4a84855019dd", + "103b137bb36a47fcbbbe9b0c3f2e2a20", + "50ac65735b464186a73dd287df8bdb90", + "8ad023a1d4414a33bf73eaf801cbd3c4", + "57a0365d6e264988a9f8340c13cb32ac", + "03e87b2770764a44b0fb60c69940fa8a", + "5d116e6c9d944632a0bb3667425ce1fa", + "2e4b3d2637214494a1e3144a63f6b2d8", + "48eed094358c4c33a1fec51e83ad1449", + "331f64d00dc547d7928e433cd4bffde1", + "b2f473ff0fdf49698f439d63ad6e6954", + "27960ebdc9b64bfc854a283e2907e11b", + "29150d9e2a414583870407fcd56e0287", + "faa2148c3d1849708c7c61edd90e1291", + "7ce09c539e7e43239b274b2951847b4e", + "8f0006a1050e49819bfecf9817429c51", + "5f21fb315ce049e49d37e44aa6adf375", + "7a860c9a51884bc28dbc95be3a5eff52", + "743dd24c3e314c0590a187f1166bc10e", + "6348038c38224d04af7bf57abedabec9", + "e77db813dca54e869bea4a928040769a", + "101ae0ce1af94c45a5f01989c271074d", + "da1ce1311a7a49a9b83bd4b6edeb6f98", + "6e8070d424684b45bc2d2452edfd1ca6", + "96a3c2562f2e4d97b8e11bfea7092ad1", + "e51e2fae2577476eb17a5589654e4146", + "b65b184f71e5418299c8c15f2982e874", + "49e5341ae44b43bc887609a461efc80b", + "4a14a6ec2d3348dcbc9875ec7af4e928", + "53f2f6f68bce41c08df12776081ea727", + "a752a853b6da4c9a867cbc4c356a5f86", + "9f59240c317a4919bced1fea1302825f", + "17e293d4e9764a2c9336651c5186597c", + "ece37dfc7f7846089b7ae9f620da5590", + "6849f7fa0d6f41ab9c8a3fafadd166b1", + "cf90653728a544029afdf0d285db1b71", + "14dfa39560914f5e9269e122d47adcfa", + "2f1edcd918d446e5bf1c0b48d8ea442f", + "9fe43efc7832435a91ce56ba8c6b0e71", + "cfc3eed1a714480ea5c25697e9cfb760", + "3083d2e358de4e00a24910dbff9d83d0", + "ed779a27748c4413b93ddae88e3b6847", + "4fd7a055897d495da333b612468f50d3", + "ff128da02ac640b8815356d193efb837", + "5d21a03a00ed4c4e8772c1b2aa49036e", + "c09e5bcfc73a436e8ab8bce80a2f066c", + "091cf2b9b40b414e9463f51088f93be9", + "bd24262a245b4a8fa786bc8a172e64d0", + "2247bf9c5e134d28ac140fa9947cbadd", + "7b312daa8c8d4f4693a43fb24c9167a7", + "a227c49da5464a3db3817b29583b19a2", + "f45de29667c64d98a6d84e5fc642c631", + "cc1285bdc1a74576929e696b39cdff32", + "c11a0b4153bb41229b54f2c316e49fb6", + "e0b7aafcb493493eb7cc38dcc2e7e790", + "88123fd47960496e989711120607b605", + "f0607bf5f1644ca2950b93029d08cdef", + "54afe3c681fd4869b5cc34d9aa410881", + "31a5f2acf0774510a8f94b1dd0c3611f", + "6c3a98e141ef41ebac5033241e901a0a", + "176b8cafeae846b08bd905108c49c187", + "f88883a2b4ba433692a7d91e76cb64c2", + "170c77c2f53347eba458933ccc9fade6", + "b673982fde464818902b9d9188682521", + "631e42e29fa24b01bdf65a52c5a3789e", + "c47cbc67f63d4664a525f45cb9be802f", + "4aec1986363b4a899ff12c1670eb99d4", + "119a284ae3b940bea7c0fb71473cac17", + "036e4baeb0f84146aad777ed9987dbdb", + "f148afd0ea3a4625a3600fc67c3693ff", + "134eb7ee8cc64f68be7803f5d10e415c", + "a136e3374ce04534a06061f743d710d5", + "0e2ae121d9514519b6e71da13bc5b3eb", + "19bb84dc4f074dd2b18a994ce05b6cb2", + "28908c600d00452f9a15cc76962fbc65", + "800b1826eb8a4fac98702973a4329c9b", + "aee41a66745047fba6a396645a7b8ad2", + "561482bb8bda448b8ac9f924ebac2c49", + "b224a2ff47304317af4868ac6370ffbd", + "819b4436cf3548f29ac4d5ed3fb45eb8", + "4cc3497b5dca4bb092237b8dbef8cb8f", + "c8f695256a574888af49e942ff0d53ea", + "783b37e7224247b5ad69a3a9fe83cab0", + "6513da4ffafb4d01b5c487ac7cf931ae", + "b40b9defd0e54112a478434d87f3d37c", + "afa45e41b7894012966afdceddbdcef9", + "203d55b28e7b4c12940f1af7e0fb5fcd", + "907e7eeceda44049b47167d5772392d8", + "2968cd77eaac49d09fc69844d62d533e", + "24107da359a7483c83160459daa1091c", + "a7e7f2bcb26848f09f12b01bc1820c98", + "77a3ae393cd54d0f90573d4b2f962c6c", + "03c4214a21fe476fa585f7bc35d5db34", + "12efe63c7cbb426a9cbf135ca597c637", + "a6b98b78fc9c4106be98cc9c76420e45", + "08050b72b51745a0bb4a6db7eee67474", + "51de3b840a3344c8b1131aa08d0c48af", + "fa8df0bc1a3d4b469ee5f3d25a0f92d2", + "e2a9cc1c6dea443ca1aa1841fa3fce5a", + "5d09e24e29e94a9493293cb44f2f05ed", + "e8d243e979184d43b46d66e8eaeec7fc", + "18d30486f46544ba947954cad0897d53", + "5887ca685a454f069902494c857eff62", + "2fa9970eb2344e038499dc2a08791f13", + "48333bff75384cf7886c81ca1e3f0056", + "a3e103155f8048798c0ac10a88493730", + "e4fa28df40184fef85979ecf49eb0227", + "8543f611eeb1412bad6d60f9188daa72", + "d5cfe8ba6de44341a3a93ad3a4453def", + "0a5c47146e3841d7826ec9f9ebc4ebaf", + "29dad287ff434262917e99d4abe87e22", + "b068791a98704c6e8ab258319dad8263", + "899083680c9848b4879aebd89f447fc8", + "cd7c7e091fc24d328e550c0c49fc3a8a", + "021e47894cca42c88d89421b56dfb919", + "3cc8a7fba51942de9e82264e548c62a5", + "dce8d86194e345cc9fe8792d1bd457e8", + "3eff3edded23414db81879b4c2f6f5b8", + "3c8c8708d15d43af8d9a86b752f019c9", + "d00f6502d78f48a6afd47fef76056b0c", + "ab2dcf296209485aa2bdcc204e782715", + "789c4051b78e427c80d9505e4144f46a", + "90f631a62ce44f6db314bd9cf1451074", + "9f1ee508f1b0446797118ce36c038fd4", + "ac11c98a0f884eabb0111353c01533ed", + "8cba9c6709e5454ea15349dc42cfe0cd", + "f9b7ccdfa2be41a7a8f7a7a64699b47a", + "bbc25d75785846ebadf149ac3bc399e2", + "c24c9d09c1ff4c4497c11e087cb74601", + "eecb9deb211c43c7b99d28a147d64574", + "f909105afa944e23a3bd7448050b8e24", + "dd7333bf31cb4da9b0cbe872d706569b", + "5c2bdf30acb64fde97964052bf1158ea", + "c42e9afe917b4d238b64c8dae423a08c", + "a52384c27ba84d7ea578c9b8973931f7", + "2a928efa36a84ee6b7ddd50505f8bed9", + "07b7b5dcb848469e8f53eeedf1bc6b33", + "3a923915a02341c8adda26e702a58649", + "ea77318badcd47a48dc6631fc4b34705", + "bc896c2b5a674b58a8f4297c86335e6c", + "524439135fb54e3ba86f5ace4eb06338", + "8e6a75869f2f4ac5a531530b43b40718", + "5e923969e34848c6851b2b03c7b41841", + "6cb7b43df77648d39950587fb4839546", + "3ac04713cef64e8cb11d8a4d405726c4", + "b0133d98440d4496995d89a6c3d24a9c", + "81bbb203f78c4e9ca03bae7163d04459", + "02deb853ae5945098b5c1598e0782932", + "3f9b1734cae4441e8e9842e786e3a666", + "2f58726958f648ebbadb90e95bbdfdc6", + "e9add7d8e3534205a85161a1dd8c0561", + "c732b4b99e5e43de98eba24ea9330b8c", + "0a6bc2c7f6cc4af7868ec259cf8e2d10", + "b462c001fb154c4794053ce3126dd644", + "22da81f202af4f88849537be607e9ee3", + "eac934f0739245f6ab3366ce113ca5ea", + "a2a5801a03eb4c488bea54a303de8aa8", + "f58e5e4225644425a58df21cc258b2e9", + "a3c33f5a9a25492aa0e775ed7afe26f2", + "1ae29602ef9a44abb3182f797198a743", + "e8eead01a58840588b916d34bac88da9", + "890891d40cbd42c19ac36100fd39b3c4", + "4ba6608f281b443094cd1a057fc56edf", + "e56dddf291fc4a87a8abcf35deb3ada4", + "3593ff33dc6a422691e37ae61708a66b", + "7144eb829e304795b3a54362a2d3308d", + "3c9251f3f32a49189ed62cf12908b655", + "f110be5d117b49ffb8f696ebeb44fd54", + "9ebee1344386470abd6ecb7c73c114e8", + "a66f018d98b043a69b1877d53170c040", + "22d5c7797b224ceeab780e907164a7f8", + "203ae02e062e45ed9a3f521242fdeff7", + "ae7f89fa88e4492e8d47b8c7592c1271", + "5c9b296e4e2248bd80b763abfa0d3aa9", + "d0e3de0c45944a3ca22baafdb51612b6", + "7be149c51b0b4709b53a97c054ee154d", + "53514d6c6a5747c781da5d5731076fa3", + "6113dfc521c64c89abc5c0a20499381f", + "67091d0ab8274792a1ee046e7d5ba315", + "4c5db6fbb19943c19b6a91c9ebb72227", + "ec0d2f874c0b4d90b70dab8a364a7177", + "0aed735a0bef4bca94cc0f83fc6bb741", + "b560e10add5d49dc875984178fb6c6bb", + "586ca83e63894831b02c18cd6d50ac67", + "49a0cb79625a46dc9241a2707a27e52a", + "67c16e3db25c47b581acbe130118fbb9", + "b0f4c8fb387e489b942f9f0d6ae7d8ea", + "246b3248809140ce93eb13901bed3892", + "31eb075cdf584cfa829bc3f119aa9244", + "8e7e13c148344fcbbe81f9a38bda633b", + "1af74cb9bbf24e2e805ca966acbe0907", + "1c19b3d200d14671994983a2b480d525", + "9fe0c115193a46c2839b7dba4930ab81", + "3cde40f339394878b928ec180b8e4e64", + "d63a1a9bacb04337b03301301ceed042", + "33e6c841c0154edbb81d53bf5de15b9a", + "975b6c14f7204bd39dcfc6af693c85b1", + "6df28ba2fc2d46cc8b51f0d80c8ba25d", + "7ef0a9a688f447a98ef9341b72b1a6ba", + "5671f7eaab934f108a1202ab876c0da9", + "07729109119944f9bfdf4bfb15f68e0b", + "4d6169d06e3f420abdfe10140b2f1752", + "43130a49034c46deb88430a97b67b772", + "2e3cf4039bd7412889f96e0f5074d17b", + "3885a42d96a44dfcbd3448c4f32a356f", + "5911fd23e2c840d9a59cadc4fcdb797d", + "0ea178dd6d3540bd87787328120fd36b", + "db212b22656948d9a190fc4a1a22d139", + "7b33cc704c9140f195ac96f687d735e9", + "7ae860cacde943d9b40ce530f3de23e7", + "2d4feafdf81144ac9ec7610c6bd7bec5", + "eb974dbc33d040f9b178b3a77dd40596", + "a73eb569400d41ff84133f7c31197f10", + "94b0542bd9a24f47829d80d75e9e6caf", + "3ee03c10f050486a953717e911d126c8", + "79bee0ed60c84ba5aea9f9f0b1314031", + "a097f30c0c204cb9924d6f6bdd709cbe", + "4e4b06c04fb9400b9a89aacaa0b1926a", + "1d903dbd3c9c4f059e5f539cb8d49e80", + "d83d719827dc4cf18fd6b4be1a013b48", + "cc5789103b634ea091fe10e89a0fa387", + "1c7fe430ec1147afabbc3b8f2733595f", + "0c1de1c66eed49ad826796f167c875fe", + "9313d0d4d0794c448c119cb081eeefd8", + "5a8d30cc9ab2422094515bd3fa829cf0", + "691e3d84fe9642f592bc6621df965af6", + "6e366f2178ab48519debac50a89d8b9f", + "8819541346574b2f9b8ad66a924f66a0", + "484a5d3a19474d23821c279f602e067d", + "6daa75d66b5e4ae9a248ca81f9a973c4", + "d43d30e849b048c5b038c0ea28051a29", + "14907f787b0b4e1da4a252d16f1928f9", + "a0ab8aa511344baf879297df64c2f9fc", + "dbb3626925144fbb9366336171f85a41", + "eadafdb5fc3d4f3b84df9ae41c5854aa", + "cdeb0f7de79e4f06b4c76d92d276cb20", + "72d85446467f44819931d0fc1ef388ca", + "73622e0503054ee4aa0a851c245eb607", + "0eca4509b4a94446874ac1614104642b", + "1a6d7e044bf341b88232922836650fef", + "d5ef045581f049caa9d79f10907e526a", + "02349ea7bced4c8186933cd0134487f2", + "c91100e69a0e4320a37a979b0586d808", + "691fc75d0196480c94281c9f8c4e4444", + "3c1323bad0314e4fa563e498e7bda9f6", + "ff75dc1b2fbd42dd804840d7a2e6a5e3", + "6942c1a729a14fb7823c10209797414f", + "0d91c6de914d46af8891967ed2d6775a", + "97cdd8befbe4449f9a005e3b33848f00", + "8d6de7a9be714081a8e1369deb51dee6", + "56ddb3c87b764bdc96a118235ed5c1e1", + "f5bdab9255224de7ae62b4c83169c022", + "68fdb591245f4e2d9df83514d7d5e6bb", + "256268cbec374eae90521d3b14c86c9f", + "918c0123e33f453fa046d906e31191f7", + "12f90753525d4938bd9ccdd3affdf222", + "bedfd3bf09594024adfbcc6c76b3d120", + "8f76fcea6a0a45d1af4d5e4985ababda", + "fea61d5d08c349faae33df0f4b6cbbb9", + "4a8debce9ea84992af1a53c9aaa7470d", + "199b2ba5fee04882ae0d71a1f06c8c29", + "10bb79a6159545a9a8e1f0a2e1a2cf03", + "93470f3024cc4db09420bcf82df30ed0", + "b9b5f84e0ad04dfdaa801aae0759b7c8", + "a240a470cabe4ec5aba95cbec336c87f", + "7ae73c7bbf9f4dc7bc28d31f17f6d5d0", + "b30a5a9d17284e919da9c824022469c0", + "07f20a998e834aa681080aa17e2cef27", + "412e24ef862f483093195c1c2dad9700", + "333b116b292148699bda35d8da71f3a8", + "56b57990ab094da3accd27ee807e9a92", + "680893a87c164913972e227461e4853c", + "175aa4436adf4ba699b550ec31f13f8c", + "e4e08a2301f6407eb5cc13c15102efe6", + "5b2c06adca494ad8b235031e32e3d769", + "cf72bf7126a24a8281cfc4ff0dac558b", + "59b6ed718ae547519a7520bd0ba8cff6", + "7bea23ddd64f4b229e869423fca4a3fa", + "3e535346524042d1b6d156a73faf2fc9", + "2ee030af4e5541489a20050aad8efce5", + "d169d623177b4f73a73034c7f0b50b5d", + "da6176592b274c47aaeecc2428c76c9c", + "273f928c594e471290863f82079d9180", + "43ce5cc7a3794a9faed7a053c984636e", + "c171ca6ce6c342e3a2b554f0a1e96946", + "df60c4135a444a448b0d200ecdd01e43", + "acbd9aa0859342e19a0e0ce928d6ad05", + "5ce8d4f4ca734748adf31e8a5328a430", + "5955d67a815e42cbbc391fec4784bea1", + "83fa2586801d4cbdac47384f78e906ba", + "6469faa7ce30401c8406ace5479d0744", + "55ebce6aedaf44569ebe813c11d86db0", + "31a8648ed6174b3ea0d6cca904f8018c", + "4a9dadfe582049babf7e91c7d956de55", + "f62028910b1a4e299444705e7795058c", + "26668e33d9dd4d67b39da870b6b26df8", + "9bda89af8a87453894b70a571544af1e", + "7b10ca1619e948dd91248c7ec8b075ef", + "eabdb0f39f1f43cf8f5e37b2abfc279f", + "5d11defaa1624b83a8a47e4745a13d7a", + "5d57d4c3e3a24cac8a8ab228b199ca22", + "921a4b00691a4346b04ee18dda85fe9c", + "0b36b8a64f4846b58a5a73ffb5076123", + "071b189c1ef64856808a5430060c4308", + "52db1d1561db4f5ca9b881ff55320251", + "bf97514daefb48869a318e5e617483a1", + "6e5f2583b8cc4cc8a1218f2c2bec6297", + "60102f86fd2742cdb8c73a720c558b21", + "92b11b42862d464fa908abaeb6a2e437", + "a1003fa3bcb249b886cfc6a7fb50f3b7", + "d0fe8f14840146df9fc769f2ffc6f103", + "1dc882f2764548e1a1103da0a7d4052a", + "449171807ad14b55876489b49b09bcd8", + "eccaed078ac547328383e1fb8c8422bd", + "61bdef04eaff450ca8d552b7ebc67533", + "08147947751240079f5d4fc1ebb3d2a8", + "656ec0e3fc91481bb1fbd3aec5c9f007", + "f3c46fae7ba04122b9ea6721d3fd59f9", + "65af6aa005304854b289c94d562ee42c", + "22c7d5d6518943ae9bad7733aa3aeb6b", + "6f152e50ae2e433aa01bf9820764022c", + "9a70f8e5d1b345bda0c4aecf39e26596", + "5ee267ba68f04f27a4d44ac895c28be4", + "b1eabe6afaab4879b4e60b75a13c53f2", + "561adb0dc1c943e6ac7734d9d214f35a" + ] + }, + "id": "WDMgtIjNhLPN", + "outputId": "e24ad80e-70ee-48f5-b77a-aea87ded2688" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Python platform: Linux-4.18.0-553.123.1.el8_10.x86_64-x86_64-with-glibc2.35\n", + "Training accelerator: CUDA GPU: NVIDIA A100-PCIE-40GB\n", + "Training precision: 16-mixed\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/conda/lib/python3.11/site-packages/lightning/pytorch/utilities/model_summary/model_summary.py:242: Precision 16-mixed is not supported by the model summary. Estimated model size in MB will not be accurate. Using 32 bits instead.\n" + ] + }, + { + "data": { + "text/html": [ + "
┏━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━┳━━━━━━━┓\n",
+       "┃   ┃ Name          ┃ Type             ┃ Params ┃ Mode  ┃ FLOPs ┃\n",
+       "┡━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━╇━━━━━━━┩\n",
+       "│ 0 │ loss          │ DNACrossingLoss  │      0 │ train │     0 │\n",
+       "│ 1 │ train_metrics │ MetricCollection │      0 │ train │     0 │\n",
+       "│ 2 │ val_metrics   │ MetricCollection │      0 │ train │     0 │\n",
+       "│ 3 │ test_metrics  │ MetricCollection │      0 │ train │     0 │\n",
+       "│ 4 │ model         │ ResUNetTwoHeads  │  7.6 M │ train │     0 │\n",
+       "│ 5 │ optimizer     │ Adam             │      0 │ train │     0 │\n",
+       "└───┴───────────────┴──────────────────┴────────┴───────┴───────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━┳━━━━━━━┓\n", + "┃\u001b[1;35m \u001b[0m\u001b[1;35m \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mName \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mType \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mParams\u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mMode \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mFLOPs\u001b[0m\u001b[1;35m \u001b[0m┃\n", + "┡━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━╇━━━━━━━┩\n", + "│\u001b[2m \u001b[0m\u001b[2m0\u001b[0m\u001b[2m \u001b[0m│ loss │ DNACrossingLoss │ 0 │ train │ 0 │\n", + "│\u001b[2m \u001b[0m\u001b[2m1\u001b[0m\u001b[2m \u001b[0m│ train_metrics │ MetricCollection │ 0 │ train │ 0 │\n", + "│\u001b[2m \u001b[0m\u001b[2m2\u001b[0m\u001b[2m \u001b[0m│ val_metrics │ MetricCollection │ 0 │ train │ 0 │\n", + "│\u001b[2m \u001b[0m\u001b[2m3\u001b[0m\u001b[2m \u001b[0m│ test_metrics │ MetricCollection │ 0 │ train │ 0 │\n", + "│\u001b[2m \u001b[0m\u001b[2m4\u001b[0m\u001b[2m \u001b[0m│ model │ ResUNetTwoHeads │ 7.6 M │ train │ 0 │\n", + "│\u001b[2m \u001b[0m\u001b[2m5\u001b[0m\u001b[2m \u001b[0m│ optimizer │ Adam │ 0 │ train │ 0 │\n", + "└───┴───────────────┴──────────────────┴────────┴───────┴───────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
Trainable params: 7.6 M                                                                                            \n",
+       "Non-trainable params: 0                                                                                            \n",
+       "Total params: 7.6 M                                                                                                \n",
+       "Total estimated model params size (MB): 30                                                                         \n",
+       "Modules in train mode: 111                                                                                         \n",
+       "Modules in eval mode: 0                                                                                            \n",
+       "Total FLOPs: 0                                                                                                     \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mTrainable params\u001b[0m: 7.6 M \n", + "\u001b[1mNon-trainable params\u001b[0m: 0 \n", + "\u001b[1mTotal params\u001b[0m: 7.6 M \n", + "\u001b[1mTotal estimated model params size (MB)\u001b[0m: 30 \n", + "\u001b[1mModules in train mode\u001b[0m: 111 \n", + "\u001b[1mModules in eval mode\u001b[0m: 0 \n", + "\u001b[1mTotal FLOPs\u001b[0m: 0 \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: | | 0/? [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pathlib import Path\n", + "\n", + "import pandas as pd\n", + "\n", + "def get_latest_metrics_path(trainer) -> Path:\n", + " \"\"\"Return the metrics CSV path from the active trainer logger.\n", + "\n", + " Parameters\n", + " ----------\n", + " trainer : lightning.pytorch.Trainer\n", + " Trainer used for the most recent training run.\n", + "\n", + " Returns\n", + " -------\n", + " Path\n", + " Path to the CSV metrics file written by the trainer logger.\n", + "\n", + " Raises\n", + " ------\n", + " RuntimeError\n", + " If the trainer does not have a logger with a log directory.\n", + " FileNotFoundError\n", + " If the expected metrics CSV file does not exist.\n", + " \"\"\"\n", + " if trainer.logger is None:\n", + " raise RuntimeError(\"The trainer does not have a logger.\")\n", + "\n", + " log_dir = getattr(trainer.logger, \"log_dir\", None)\n", + "\n", + " if log_dir is None:\n", + " raise RuntimeError(\n", + " \"The trainer logger does not expose a log_dir attribute.\"\n", + " )\n", + "\n", + " metrics_path = Path(log_dir) / \"metrics.csv\"\n", + "\n", + " if not metrics_path.exists():\n", + " raise FileNotFoundError(\n", + " \"Could not find the metrics CSV for the latest run.\\n\"\n", + " f\"Expected path: {metrics_path}\"\n", + " )\n", + "\n", + " return metrics_path\n", + "\n", + "\n", + "def plot_training_metrics(metrics):\n", + " \"\"\"Plot total loss and DNA Dice curves by epoch.\n", + "\n", + " Parameters\n", + " ----------\n", + " metrics : pandas.DataFrame or dict\n", + " Training metrics loaded from the CSV logger. The object should\n", + " contain an ``epoch`` column and logged metric columns such as\n", + " ``train_loss_epoch``, ``val_loss_epoch``,\n", + " ``train_dna_dice_epoch``, and ``val_dna_dice_epoch``.\n", + "\n", + " \"\"\"\n", + "\n", + " if not hasattr(metrics, \"columns\"):\n", + " metrics = pd.DataFrame(metrics)\n", + "\n", + " metrics = metrics.copy()\n", + " metrics = metrics.sort_values(\"epoch\")\n", + " metrics = metrics.groupby(\"epoch\", as_index=False).last()\n", + "\n", + " fig, axs = plt.subplots(2, figsize=(8, 6), sharex=True)\n", + "\n", + " axs[0].plot(\n", + " metrics[\"epoch\"],\n", + " metrics[\"train_loss_epoch\"],\n", + " label=\"Train loss\",\n", + " )\n", + " axs[0].plot(\n", + " metrics[\"epoch\"],\n", + " metrics[\"val_loss_epoch\"],\n", + " label=\"Validation loss\",\n", + " )\n", + " axs[0].set_ylabel(\"Loss\")\n", + " axs[0].set_title(\"Training and validation loss\")\n", + " axs[0].legend()\n", + "\n", + " dice_columns = [\n", + " col for col in metrics.columns\n", + " if \"dice\" in col.lower()\n", + " ]\n", + "\n", + " if dice_columns:\n", + " for col in dice_columns:\n", + " axs[1].plot(\n", + " metrics[\"epoch\"],\n", + " metrics[col],\n", + " label=col,\n", + " )\n", + " axs[1].legend()\n", + " else:\n", + " axs[1].text(\n", + " 0.5,\n", + " 0.5,\n", + " \"No DNA Dice metric was logged.\",\n", + " ha=\"center\",\n", + " va=\"center\",\n", + " transform=axs[1].transAxes,\n", + " )\n", + "\n", + " axs[1].set_xlabel(\"Epoch\")\n", + " axs[1].set_ylabel(\"DNA Dice\")\n", + " axs[1].set_title(\"DNA Dice\")\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "metrics_path = get_latest_metrics_path(trainer)\n", + "print(\"Loading metrics from:\", metrics_path)\n", + "\n", + "metrics = pd.read_csv(metrics_path)\n", + "plot_training_metrics(metrics)" + ] + }, + { + "cell_type": "markdown", + "id": "naPFGb1-hLPN", + "metadata": { + "id": "naPFGb1-hLPN" + }, + "source": [ + "### DNA-focused validation metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 261, + "id": "URzcLeLdhLPN", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "URzcLeLdhLPN", + "outputId": "1d822fba-242e-4e1e-acda-774eab0de379" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "validation {'loss': 0.014928838480263948, 'dna_dice': 0.9783967590332031, 'dna_iou': 0.9578547668457031, 'cross_mse': 5.004769474908244e-05}\n" + ] + } + ], + "source": [ + "def dice_score_from_prob(\n", + " prob: torch.Tensor,\n", + " target: torch.Tensor,\n", + " threshold: float = 0.5,\n", + " eps: float = 1e-6,\n", + ") -> torch.Tensor:\n", + " \"\"\"Hard Dice score for binary DNA masks.\"\"\"\n", + "\n", + " pred = (prob >= threshold).float()\n", + " dims = tuple(range(1, pred.ndim))\n", + " inter = torch.sum(pred * target, dim=dims)\n", + " denom = torch.sum(pred, dim=dims) + torch.sum(target, dim=dims)\n", + " return ((2.0 * inter + eps) / (denom + eps)).mean()\n", + "\n", + "\n", + "def iou_score_from_prob(\n", + " prob: torch.Tensor,\n", + " target: torch.Tensor,\n", + " threshold: float = 0.5,\n", + " eps: float = 1e-6,\n", + ") -> torch.Tensor:\n", + " \"\"\"Hard IoU score for binary DNA masks.\"\"\"\n", + "\n", + " pred = (prob >= threshold).float()\n", + " dims = tuple(range(1, pred.ndim))\n", + " inter = torch.sum(pred * target, dim=dims)\n", + " union = torch.sum((pred + target) > 0, dim=dims)\n", + " return ((inter + eps) / (union + eps)).mean()\n", + "\n", + "\n", + "def evaluate_loader(model, loader, stage: str) -> dict[str, float]:\n", + " \"\"\"Evaluate DNA Dice, DNA IoU, and crossing MSE.\"\"\"\n", + "\n", + " model.eval()\n", + " device = next(model.parameters()).device\n", + " totals = dict(loss=0.0, dna_dice=0.0, dna_iou=0.0)\n", + " totals['cross_mse'] = 0.0\n", + " count = 0\n", + "\n", + " with torch.no_grad():\n", + " for image, target in loader:\n", + " image = image.to(device)\n", + " target = target.to(device)\n", + " pred = model(image)\n", + " loss = loss_fn(pred, target)\n", + " dna_prob = torch.sigmoid(pred[:, 0:1])\n", + " cross_prob = torch.sigmoid(pred[:, 1:2])\n", + " target_dna = target[:, 0:1]\n", + " target_cross = target[:, 1:2]\n", + " batch_size = int(image.shape[0])\n", + "\n", + " totals['loss'] += float(loss) * batch_size\n", + " totals['dna_dice'] += float(\n", + " dice_score_from_prob(dna_prob, target_dna)\n", + " ) * batch_size\n", + " totals['dna_iou'] += float(\n", + " iou_score_from_prob(dna_prob, target_dna)\n", + " ) * batch_size\n", + " totals['cross_mse'] += float(\n", + " F.mse_loss(cross_prob, target_cross)\n", + " ) * batch_size\n", + " count += batch_size\n", + "\n", + " metrics = {key: value / max(count, 1) for key, value in totals.items()}\n", + " print(stage, metrics)\n", + " return metrics\n", + "\n", + "\n", + "val_metrics = evaluate_loader(unet_app, val_loader, 'validation')" + ] + }, + { + "cell_type": "code", + "execution_count": 262, + "id": "0c3918ed-6048-4a9c-a578-12ec5b7fb585", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cross target max: 0.9834339022636414\n", + "Cross pred max: 0.8543996214866638\n", + "Cross target positive pixels: 690\n", + "DNA positive pixels: 28294\n", + "Mean pred at crossing pixels: 0.2446327805519104\n", + "Mean pred on non-crossing DNA: 0.0008099295082502067\n", + "Mean pred on background: 0.004565902519971132\n" + ] + } + ], + "source": [ + "def inspect_crossing_batch(batch, model) -> None:\n", + " \"\"\"Print crossing target and prediction statistics.\"\"\"\n", + " image, target = batch\n", + " model.eval()\n", + " device = next(model.parameters()).device\n", + "\n", + " with torch.no_grad():\n", + " pred = model(image.to(device))\n", + " cross_prob = torch.sigmoid(pred[:, 1:2]).cpu()\n", + "\n", + " target_cross = target[:, 1:2].cpu()\n", + " target_dna = target[:, 0:1].cpu()\n", + "\n", + " positive = target_cross > 0.05\n", + " dna_region = target_dna > 0.6\n", + "\n", + " print(\"Cross target max:\", float(target_cross.max()))\n", + " print(\"Cross pred max:\", float(cross_prob.max()))\n", + " print(\"Cross target positive pixels:\", int(positive.sum()))\n", + " print(\"DNA positive pixels:\", int(dna_region.sum()))\n", + "\n", + " if int(positive.sum()) > 0:\n", + " print(\n", + " \"Mean pred at crossing pixels:\",\n", + " float(cross_prob[positive].mean()),\n", + " )\n", + "\n", + " non_cross_dna = dna_region & ~positive\n", + "\n", + " if int(non_cross_dna.sum()) > 0:\n", + " print(\n", + " \"Mean pred on non-crossing DNA:\",\n", + " float(cross_prob[non_cross_dna].mean()),\n", + " )\n", + "\n", + " background = ~dna_region\n", + "\n", + " if int(background.sum()) > 0:\n", + " print(\n", + " \"Mean pred on background:\",\n", + " float(cross_prob[background].mean()),\n", + " )\n", + "\n", + "\n", + "batch = next(iter(val_loader))\n", + "inspect_crossing_batch(batch, unet_app)" + ] + }, + { + "cell_type": "markdown", + "id": "qzz07wo9hLPN", + "metadata": { + "id": "qzz07wo9hLPN" + }, + "source": [ + "### Optional prediction preview" + ] + }, + { + "cell_type": "code", + "execution_count": 263, + "id": "THN5kDG3hLPN", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 259 + }, + "id": "THN5kDG3hLPN", + "outputId": "7ac3caf4-24dd-4bb3-e693-16bf65b1c901" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def show_prediction(\n", + " batch: tuple[torch.Tensor, ...],\n", + " model: torch.nn.Module,\n", + " index: int = 0,\n", + ") -> None:\n", + " \"\"\"Visualize the model's predictions against ground truth for one sample.\n", + "\n", + " This function takes a batch of data, performs an evaluation-mode forward\n", + " pass using the provided model, and plots the image, the DNA segmentation\n", + " (target vs. prediction), and the crossing detection (target vs. prediction)\n", + " masks.\n", + "\n", + " Parameters\n", + " ----------\n", + " batch : tuple[torch.Tensor, ...]\n", + " A tuple containing (images, targets).\n", + " - images: Tensor of shape (B, C, H, W).\n", + " - targets: Tensor of shape (B, 2, H, W) containing DNA and crossing\n", + " masks.\n", + " model : torch.nn.Module\n", + " The neural network (e.g., U-Net or ResU-Net) used for inference.\n", + " index : int, optional\n", + " The index of the specific sample within the batch to visualize.\n", + " Defaults to 1.\n", + "\n", + " Returns\n", + " -------\n", + " None\n", + " The function displays a Matplotlib figure and does not return a value.\n", + "\n", + " Notes\n", + " -----\n", + " The function automatically handles device placement (CPU/GPU) by checking\n", + " the model's parameters and applies a sigmoid activation to the model\n", + " output to transform logits into probabilities.\n", + "\n", + " \"\"\"\n", + "\n", + " image, target = batch\n", + " model.eval()\n", + " device = next(model.parameters()).device\n", + "\n", + " with torch.no_grad():\n", + " pred = model(image.to(device))\n", + " dna_prob = torch.sigmoid(pred[:, 0:1]).cpu()\n", + " cross_prob = torch.sigmoid(pred[:, 1:2]).cpu()\n", + "\n", + " panels = [\n", + " image[index, 0].cpu(),\n", + " target[index, 0].cpu(),\n", + " dna_prob[index, 0],\n", + " target[index, 1].cpu(),\n", + " cross_prob[index, 0],\n", + " ]\n", + " titles = [\n", + " 'image',\n", + " 'dna target',\n", + " 'dna pred',\n", + " 'cross target',\n", + " 'cross pred',\n", + " ]\n", + "\n", + " fig, axes = plt.subplots(1, len(panels), figsize=(15, 3))\n", + " for ax, panel, title in zip(axes, panels, titles):\n", + " ax.imshow(panel, cmap='gray', vmin=0.0, vmax=1.0)\n", + " ax.set_title(title)\n", + " ax.axis('off')\n", + " plt.show()\n", + "\n", + "\n", + "batch = next(iter(val_loader))\n", + "show_prediction(batch, unet_app)" + ] + }, + { + "cell_type": "markdown", + "id": "cc_My3GrTgFm", + "metadata": { + "id": "cc_My3GrTgFm" + }, + "source": [ + "# 17. Evaluation on real data" + ] + }, + { + "cell_type": "code", + "execution_count": 264, + "id": "3YLZtTblTfuf", + "metadata": { + "id": "3YLZtTblTfuf" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using existing real test data root: all_data\n" + ] + } + ], + "source": [ + "from pathlib import Path\n", + "import zipfile\n", + "\n", + "\n", + "TEST_ZIP_PATH = Path(\"data_picoz.zip\")\n", + "TEST_ROOT = Path(\"all_data\")\n", + "\n", + "\n", + "if TEST_ROOT.exists():\n", + " print(\"Using existing real test data root:\", TEST_ROOT)\n", + "\n", + "else:\n", + " if not TEST_ZIP_PATH.exists():\n", + " raise FileNotFoundError(\n", + " \"Set TEST_ROOT to an existing test-data folder, or set \"\n", + " \"TEST_ZIP_PATH to an uploaded real test zip file.\\n\"\n", + " f\"Current TEST_ROOT: {TEST_ROOT}\\n\"\n", + " f\"Current TEST_ZIP_PATH: {TEST_ZIP_PATH}\"\n", + " )\n", + "\n", + " TEST_ROOT.mkdir(parents=True, exist_ok=True)\n", + "\n", + " with zipfile.ZipFile(TEST_ZIP_PATH, \"r\") as zip_ref:\n", + " zip_ref.extractall(TEST_ROOT)\n", + "\n", + " print(\"Extracted real test data to:\", TEST_ROOT)" + ] + }, + { + "cell_type": "code", + "execution_count": 265, + "id": "2pCKb3H7fK_c", + "metadata": { + "id": "2pCKb3H7fK_c" + }, + "outputs": [], + "source": [ + "TEST_EXTENSIONS = {\".jpg\",\".jpeg\",\".tif\",\".tiff\",\".npy\"}\n", + "\n", + "IMAGE_KEYWORDS = (\"image\",\"images\",\"img\",\"afm\",\"raw\")\n", + "\n", + "DNA_MASK_KEYWORDS = (\"mask\",\"masks\",\"label\",\"labels\",\"seg\",\n", + " \"segmentation\")\n", + "\n", + "CROSS_MASK_KEYWORDS = (\"cross\",\"crossing\",\"crossings\")\n", + "\n", + "\n", + "def is_data_file(path: Path) -> bool:\n", + " \"\"\"Return whether a path has a supported image or array suffix.\n", + "\n", + " Parameters\n", + " ----------\n", + " path : Path\n", + " Candidate file path.\n", + "\n", + " Returns\n", + " -------\n", + " bool\n", + " True if the file suffix is supported.\n", + "\n", + " \"\"\"\n", + "\n", + " return path.is_file() and path.suffix.lower() in TEST_EXTENSIONS\n", + "\n", + "\n", + "def path_text(path: Path) -> str:\n", + " \"\"\"Return a lower-case path string for keyword matching.\n", + "\n", + " Parameters\n", + " ----------\n", + " path : Path\n", + " File path to convert.\n", + "\n", + " Returns\n", + " -------\n", + " str\n", + " Lower-case path string using forward slashes.\n", + "\n", + " \"\"\"\n", + "\n", + " return path.as_posix().lower()\n", + "\n", + "\n", + "def contains_any(text: str, keywords: tuple[str, ...]) -> bool:\n", + " \"\"\"Return whether any keyword is present in text.\n", + "\n", + " Parameters\n", + " ----------\n", + " text : str\n", + " Text to search.\n", + " keywords : tuple[str, ...]\n", + " Keywords to look for.\n", + "\n", + " Returns\n", + " -------\n", + " bool\n", + " True if any keyword is present.\n", + "\n", + " \"\"\"\n", + "\n", + " return any(keyword in text for keyword in keywords)\n", + "\n", + "\n", + "def normalized_stem(path: Path) -> str:\n", + " \"\"\"Return a comparable stem with common prefixes removed.\n", + "\n", + " Parameters\n", + " ----------\n", + " path : Path\n", + " File path whose stem should be normalized.\n", + "\n", + " Returns\n", + " -------\n", + " str\n", + " Normalized stem used for matching images to masks.\n", + "\n", + " \"\"\"\n", + "\n", + " stem = path.stem.lower()\n", + "\n", + " prefixes = (\n", + " \"img_\",\n", + " \"image_\",\n", + " \"afm_\",\n", + " \"raw_\",\n", + " \"dna_\",\n", + " \"mask_\",\n", + " \"label_\",\n", + " \"seg_\",\n", + " \"cross_\",\n", + " \"crossing_\",\n", + " )\n", + "\n", + " changed = True\n", + " while changed:\n", + " changed = False\n", + " for prefix in prefixes:\n", + " if stem.startswith(prefix):\n", + " stem = stem[len(prefix):]\n", + " changed = True\n", + "\n", + " return stem\n", + "\n", + "\n", + "def collect_test_files(root: Path) -> tuple[list[Path], list[Path], list[Path]]:\n", + " \"\"\"Collect candidate image, DNA mask, and crossing files.\n", + "\n", + " Parameters\n", + " ----------\n", + " root : Path\n", + " Root directory containing the extracted real test data.\n", + "\n", + " Returns\n", + " -------\n", + " tuple[list[Path], list[Path], list[Path]]\n", + " Candidate image files, DNA mask files, and crossing mask files.\n", + " \"\"\"\n", + " image_files = []\n", + " dna_files = []\n", + " cross_files = []\n", + "\n", + " for path in root.rglob(\"*\"):\n", + " if not is_data_file(path):\n", + " continue\n", + "\n", + " text = path_text(path)\n", + " has_cross = contains_any(text, CROSS_MASK_KEYWORDS)\n", + " has_dna = contains_any(text, DNA_MASK_KEYWORDS)\n", + " has_image = contains_any(text, IMAGE_KEYWORDS)\n", + "\n", + " if has_cross:\n", + " cross_files.append(path)\n", + " elif has_dna:\n", + " dna_files.append(path)\n", + " elif has_image:\n", + " image_files.append(path)\n", + "\n", + " if not image_files:\n", + " for path in root.rglob(\"*\"):\n", + " if is_data_file(path):\n", + " text = path_text(path)\n", + " if not contains_any(text, DNA_MASK_KEYWORDS):\n", + " if not contains_any(text, CROSS_MASK_KEYWORDS):\n", + " image_files.append(path)\n", + "\n", + " return image_files, dna_files, cross_files\n", + "\n", + "\n", + "def index_by_stem(paths: list[Path]) -> dict[str, Path]:\n", + " \"\"\"Index file paths by normalized stem.\n", + "\n", + " Parameters\n", + " ----------\n", + " paths : list[Path]\n", + " Paths to index.\n", + "\n", + " Returns\n", + " -------\n", + " dict[str, Path]\n", + " Mapping from normalized stem to path.\n", + " \"\"\"\n", + " output = {}\n", + "\n", + " for path in sorted(paths):\n", + " output.setdefault(normalized_stem(path), path)\n", + "\n", + " return output" + ] + }, + { + "cell_type": "code", + "execution_count": 266, + "id": "73XVRC_zfqJ5", + "metadata": { + "id": "73XVRC_zfqJ5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Images without matched DNA masks: 110\n", + "all_data/__MACOSX/data/all_data/._image_0.npy\n", + "all_data/__MACOSX/data/all_data/._image_1.npy\n", + "all_data/__MACOSX/data/all_data/._image_10.npy\n", + "all_data/__MACOSX/data/all_data/._image_11.npy\n", + "all_data/__MACOSX/data/all_data/._image_12.npy\n", + "all_data/__MACOSX/data/all_data/._image_13.npy\n", + "all_data/__MACOSX/data/all_data/._image_14.npy\n", + "all_data/__MACOSX/data/all_data/._image_15.npy\n", + "all_data/__MACOSX/data/all_data/._image_16.npy\n", + "all_data/__MACOSX/data/all_data/._image_17.npy\n", + "Real test samples: 110\n", + "First real test row: {'id': '0', 'image_path': 'all_data/data/all_data/image_0.npy', 'dna_path': 'all_data/data/all_data/mask_0.npy', 'cross_path': ''}\n" + ] + } + ], + "source": [ + "def build_real_test_records(root: Path) -> list[dict[str, str]]:\n", + " \"\"\"Build DeepTrack source records for a real test dataset.\n", + "\n", + " Parameters\n", + " ----------\n", + " root : Path\n", + " Root directory containing extracted real test data.\n", + "\n", + " Returns\n", + " -------\n", + " list[dict[str, str]]\n", + " Records compatible with ``build_pipeline`` and\n", + " ``DeepTrackSourceDataset``.\n", + " \"\"\"\n", + " image_files, dna_files, cross_files = collect_test_files(root)\n", + "\n", + " dna_by_stem = index_by_stem(dna_files)\n", + " cross_by_stem = index_by_stem(cross_files)\n", + " records = []\n", + " unmatched = []\n", + "\n", + " for image_path in sorted(image_files):\n", + " stem = normalized_stem(image_path)\n", + " dna_path = dna_by_stem.get(stem)\n", + " cross_path = cross_by_stem.get(stem, \"\")\n", + "\n", + " if dna_path is None:\n", + " unmatched.append(str(image_path))\n", + " continue\n", + "\n", + " records.append(\n", + " dict(\n", + " id=stem,\n", + " image_path=str(image_path),\n", + " dna_path=str(dna_path),\n", + " cross_path=str(cross_path) if cross_path else \"\",\n", + " )\n", + " )\n", + "\n", + " if unmatched:\n", + " print(\"Images without matched DNA masks:\", len(unmatched))\n", + " print(\"\\n\".join(unmatched[:10]))\n", + "\n", + " if not records:\n", + " raise RuntimeError(\n", + " \"No matched real test image/mask pairs were found. \"\n", + " \"Check folder names and file stems.\"\n", + " )\n", + "\n", + " return records\n", + "\n", + "\n", + "test_records = build_real_test_records(TEST_ROOT)\n", + "test_source = dt.sources.Source(samples=test_records)\n", + "\n", + "print(\"Real test samples:\", len(test_source))\n", + "print(\"First real test row:\", test_records[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 267, + "id": "bjQzPfplfseS", + "metadata": { + "id": "bjQzPfplfseS" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Created test_loader with 110 samples.\n", + "real_test {'loss': 0.15740564980290153, 'dna_dice': 0.8188274838707664, 'dna_iou': 0.6962633414701982, 'cross_mse': 3.651884491608309e-05}\n" + ] + }, + { + "data": { + "text/plain": [ + "{'loss': 0.15740564980290153,\n", + " 'dna_dice': 0.8188274838707664,\n", + " 'dna_iou': 0.6962633414701982,\n", + " 'cross_mse': 3.651884491608309e-05}" + ] + }, + "execution_count": 267, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_dataset = DeepTrackSourceDataset(\n", + " test_source,\n", + " TARGET_SIZE,\n", + " augment=False,\n", + " normalize_image=False,\n", + ")\n", + "\n", + "test_loader = dl.DataLoader(\n", + " test_dataset,\n", + " batch_size=int(TRAIN_CFG[\"batch_size\"]),\n", + " shuffle=False,\n", + " num_workers=0,\n", + " persistent_workers=False,\n", + ")\n", + "\n", + "print(f\"Created test_loader with {len(test_dataset)} samples.\")\n", + "\n", + "test_metrics = evaluate_loader(\n", + " unet_app,\n", + " test_loader,\n", + " \"real_test\",\n", + ")\n", + "\n", + "test_metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 270, + "id": "OKGD106Dfyxi", + "metadata": { + "id": "OKGD106Dfyxi" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "test_batch = next(iter(test_loader))\n", + "show_prediction(\n", + " test_batch,\n", + " unet_app,\n", + " index=0,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bdf2840e-ee7a-469c-a063-519d86cf6ae4", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "T4", + "provenance": [] + }, + "kernelspec": { + "display_name": "openmm-cuda", + "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.20" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "021e47894cca42c88d89421b56dfb919": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "02349ea7bced4c8186933cd0134487f2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "02deb853ae5945098b5c1598e0782932": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "030b37cea4ba414db5fae6384ed6cdb6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "036e4baeb0f84146aad777ed9987dbdb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "03c4214a21fe476fa585f7bc35d5db34": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "03d29d4401344338a1bc1e840b8a8208": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "03e87b2770764a44b0fb60c69940fa8a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "043020ee46b04b0e849aa065eb1688e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7c8de7d0ad144b64bbfff2d0851c9ff2", + "placeholder": "​", + "style": "IPY_MODEL_5a20ac379047420483e2e3c281846da8", + "value": "Validation DataLoader 0: 100%" + } + }, + "071b189c1ef64856808a5430060c4308": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_52db1d1561db4f5ca9b881ff55320251", + "IPY_MODEL_bf97514daefb48869a318e5e617483a1", + "IPY_MODEL_6e5f2583b8cc4cc8a1218f2c2bec6297" + ], + "layout": "IPY_MODEL_60102f86fd2742cdb8c73a720c558b21" + } + }, + "07729109119944f9bfdf4bfb15f68e0b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "07b7b5dcb848469e8f53eeedf1bc6b33": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "07f20a998e834aa681080aa17e2cef27": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "07fd460123374011924050488957dfb9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fdd0ef85a11e431c8b9584622aa675f0", + "IPY_MODEL_e2f90203e06442c88ac36903ea85f8e7", + "IPY_MODEL_719b5325829f44caa738198d8d8919e2" + ], + "layout": "IPY_MODEL_851f40556b6545f1b2e8b2c49d1f3a24" + } + }, + "08050b72b51745a0bb4a6db7eee67474": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5d09e24e29e94a9493293cb44f2f05ed", + "placeholder": "​", + "style": "IPY_MODEL_e8d243e979184d43b46d66e8eaeec7fc", + "value": "Validation DataLoader 0: 100%" + } + }, + "08147947751240079f5d4fc1ebb3d2a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_22c7d5d6518943ae9bad7733aa3aeb6b", + "placeholder": "​", + "style": "IPY_MODEL_6f152e50ae2e433aa01bf9820764022c", + "value": "Validation DataLoader 0: 100%" + } + }, + "084e9fa8a9924883ab4de7f6ff398d69": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_140d409c39384bd8a39f55c3e7964c15", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9a367b91d3fb40699363c94d40a21c7c", + "value": 1 + } + }, + "091cf2b9b40b414e9463f51088f93be9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0a5c47146e3841d7826ec9f9ebc4ebaf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "0a6bc2c7f6cc4af7868ec259cf8e2d10": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a3c33f5a9a25492aa0e775ed7afe26f2", + "placeholder": "​", + "style": "IPY_MODEL_1ae29602ef9a44abb3182f797198a743", + "value": " 3/3 [00:00<00:00, 23.27it/s]" + } + }, + "0ae94f04037447acb216044112f9175b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0aed735a0bef4bca94cc0f83fc6bb741": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0b0b8dfdf0054425b83e8a4994acc8fc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0b1024f20aaa459aabd611e80ae46e53": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0b36b8a64f4846b58a5a73ffb5076123": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0c1de1c66eed49ad826796f167c875fe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0d0222a098a24c4db6e99d2e3f0921ad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7501155baee5472f9140ac1e04845f75", + "placeholder": "​", + "style": "IPY_MODEL_33c6b24328c341e190273d1ab5d3917a", + "value": "Validation DataLoader 0: 100%" + } + }, + "0d91c6de914d46af8891967ed2d6775a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0e2ae121d9514519b6e71da13bc5b3eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_19bb84dc4f074dd2b18a994ce05b6cb2", + "IPY_MODEL_28908c600d00452f9a15cc76962fbc65", + "IPY_MODEL_800b1826eb8a4fac98702973a4329c9b" + ], + "layout": "IPY_MODEL_aee41a66745047fba6a396645a7b8ad2" + } + }, + "0ea178dd6d3540bd87787328120fd36b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_eb974dbc33d040f9b178b3a77dd40596", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a73eb569400d41ff84133f7c31197f10", + "value": 1 + } + }, + "0eaa81e3e1d443c387792ee6e64fd1b6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "0eca4509b4a94446874ac1614104642b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c91100e69a0e4320a37a979b0586d808", + "placeholder": "​", + "style": "IPY_MODEL_691fc75d0196480c94281c9f8c4e4444", + "value": "Validation DataLoader 0: 100%" + } + }, + "0f6cde3fd35f4bf7ad1e8b22a2915a29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c3ae2ada559f4a77834b47afeb954e2e", + "placeholder": "​", + "style": "IPY_MODEL_1ff6d20727704f89a15e7f62263b7c03", + "value": " 3/3 [00:00<00:00, 22.62it/s]" + } + }, + "101ae0ce1af94c45a5f01989c271074d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "103b137bb36a47fcbbbe9b0c3f2e2a20": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1088c60e62f64798b702028799231729": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "10bb79a6159545a9a8e1f0a2e1a2cf03": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b30a5a9d17284e919da9c824022469c0", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_07f20a998e834aa681080aa17e2cef27", + "value": 1 + } + }, + "1119633b9b7f45bcb9274237898ae999": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "119a284ae3b940bea7c0fb71473cac17": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "12a635899c1643788e566ba87ab1723c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "12efe63c7cbb426a9cbf135ca597c637": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "12f90753525d4938bd9ccdd3affdf222": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "134eb7ee8cc64f68be7803f5d10e415c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "138d51e2eee64063b8347d75eb3002e5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "140d409c39384bd8a39f55c3e7964c15": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "14907f787b0b4e1da4a252d16f1928f9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "14dbde6953364c5c87d9469c49959066": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3de0b3794ad54c45b7c019cfd285a95e", + "placeholder": "​", + "style": "IPY_MODEL_e2362e5efae7467b8e58786955739072", + "value": " 3/3 [00:00<00:00, 17.35it/s]" + } + }, + "14dfa39560914f5e9269e122d47adcfa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "170c77c2f53347eba458933ccc9fade6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4aec1986363b4a899ff12c1670eb99d4", + "placeholder": "​", + "style": "IPY_MODEL_119a284ae3b940bea7c0fb71473cac17", + "value": "Validation DataLoader 0: 100%" + } + }, + "174d67b232ac40d695cb15665959ac0c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "175aa4436adf4ba699b550ec31f13f8c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7bea23ddd64f4b229e869423fca4a3fa", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3e535346524042d1b6d156a73faf2fc9", + "value": 1 + } + }, + "176b8cafeae846b08bd905108c49c187": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "17bdd1be5491412cacbecb7feeae2fc7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "17e293d4e9764a2c9336651c5186597c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "18d30486f46544ba947954cad0897d53": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "199b2ba5fee04882ae0d71a1f06c8c29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a240a470cabe4ec5aba95cbec336c87f", + "placeholder": "​", + "style": "IPY_MODEL_7ae73c7bbf9f4dc7bc28d31f17f6d5d0", + "value": "Validation DataLoader 0: 100%" + } + }, + "19bb84dc4f074dd2b18a994ce05b6cb2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_561482bb8bda448b8ac9f924ebac2c49", + "placeholder": "​", + "style": "IPY_MODEL_b224a2ff47304317af4868ac6370ffbd", + "value": "Validation DataLoader 0: 100%" + } + }, + "1a6d7e044bf341b88232922836650fef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3c1323bad0314e4fa563e498e7bda9f6", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ff75dc1b2fbd42dd804840d7a2e6a5e3", + "value": 1 + } + }, + "1ae29602ef9a44abb3182f797198a743": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1af74cb9bbf24e2e805ca966acbe0907": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1ba0dee7653247c8b6008c8c60dd40bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3b4b83b841ab45bb9a19e08f52bfc887", + "placeholder": "​", + "style": "IPY_MODEL_6f6933d25b4147a288c1142f8aa49e24", + "value": " 3/3 [00:00<00:00, 18.34it/s]" + } + }, + "1c19b3d200d14671994983a2b480d525": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1c7fe430ec1147afabbc3b8f2733595f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1c9744b2ed434eedba77eb04cabdf204": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_61c1424c837a411d91e1e361e2f663fb", + "IPY_MODEL_5d24e35625b1440fb3e0254d16762b22", + "IPY_MODEL_995eb88c1ce5422b83ec25f99a059bb0" + ], + "layout": "IPY_MODEL_3e98332b532745d3bbcac8801aae2a31" + } + }, + "1d903dbd3c9c4f059e5f539cb8d49e80": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5a8d30cc9ab2422094515bd3fa829cf0", + "placeholder": "​", + "style": "IPY_MODEL_691e3d84fe9642f592bc6621df965af6", + "value": " 3/3 [00:00<00:00, 21.83it/s]" + } + }, + "1dc882f2764548e1a1103da0a7d4052a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1f272fa725454bb3bf529bdf2604eb12": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1ff6d20727704f89a15e7f62263b7c03": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "201b24c9f69c4af18145260bb4ecb762": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "203ae02e062e45ed9a3f521242fdeff7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ae7f89fa88e4492e8d47b8c7592c1271", + "IPY_MODEL_5c9b296e4e2248bd80b763abfa0d3aa9", + "IPY_MODEL_d0e3de0c45944a3ca22baafdb51612b6" + ], + "layout": "IPY_MODEL_7be149c51b0b4709b53a97c054ee154d" + } + }, + "203d55b28e7b4c12940f1af7e0fb5fcd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_03c4214a21fe476fa585f7bc35d5db34", + "placeholder": "​", + "style": "IPY_MODEL_12efe63c7cbb426a9cbf135ca597c637", + "value": " 3/3 [00:00<00:00, 20.55it/s]" + } + }, + "209c4f3f80e14a969afb2b32c7216dbd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_12a635899c1643788e566ba87ab1723c", + "placeholder": "​", + "style": "IPY_MODEL_9504247d6ca649aea2ef4ad828f523a6", + "value": " 3/3 [00:00<00:00, 23.69it/s]" + } + }, + "215a7a11baf44b5782096bc13d88a0be": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "2247bf9c5e134d28ac140fa9947cbadd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "22ad0c58d4a94b469e15b425c20edb60": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "22c7d5d6518943ae9bad7733aa3aeb6b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "22d5c7797b224ceeab780e907164a7f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "22da81f202af4f88849537be607e9ee3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2345ab7c9cfb4dc295f34c54579408fb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "23d930a463d04ebbac79f8ada451c1af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_945010c321a84e41828d564ccd6cab17", + "IPY_MODEL_f65b58b468a442fa9eeef48cccb9164f", + "IPY_MODEL_2fa51f1fbb8b41359089e64ea3d9e709" + ], + "layout": "IPY_MODEL_84d2ca2125194162937cd60d202efee3" + } + }, + "24107da359a7483c83160459daa1091c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2426adb29a43459895b1f5192654b6ec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "246b3248809140ce93eb13901bed3892": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "256268cbec374eae90521d3b14c86c9f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "26668e33d9dd4d67b39da870b6b26df8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_921a4b00691a4346b04ee18dda85fe9c", + "placeholder": "​", + "style": "IPY_MODEL_0b36b8a64f4846b58a5a73ffb5076123", + "value": " 3/3 [00:00<00:00, 19.02it/s]" + } + }, + "2701cb8cf0b64ae0b15efe9c0e32dd01": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2bc4378549914bd4a48aaf0a677ddc41", + "placeholder": "​", + "style": "IPY_MODEL_8cc548cea0c247d4ae5ab1eeed9cc475", + "value": " 3/3 [00:00<00:00, 22.08it/s]" + } + }, + "273f928c594e471290863f82079d9180": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_acbd9aa0859342e19a0e0ce928d6ad05", + "placeholder": "​", + "style": "IPY_MODEL_5ce8d4f4ca734748adf31e8a5328a430", + "value": "Validation DataLoader 0: 100%" + } + }, + "277bc910427c41c09786efadfb15e973": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "27807cb739b249a59a6e0d9d317414df": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "27960ebdc9b64bfc854a283e2907e11b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "279a78ac51154592a3d288be64dc843f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "28908c600d00452f9a15cc76962fbc65": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_819b4436cf3548f29ac4d5ed3fb45eb8", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4cc3497b5dca4bb092237b8dbef8cb8f", + "value": 1 + } + }, + "2902a8dadce1454491f29a01b6655cd3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "29150d9e2a414583870407fcd56e0287": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2968cd77eaac49d09fc69844d62d533e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "29dad287ff434262917e99d4abe87e22": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2a928efa36a84ee6b7ddd50505f8bed9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2b2610ec8b884911a15455ebb9f8852b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b88126853b94cf085854107c124e754": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2bc4378549914bd4a48aaf0a677ddc41": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2c4a4a15fc154209857e5bc221d4a60b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8e84599c746a4d149d3f8930f2fab49d", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9d7149c5a5174b5da388a5898036e8af", + "value": 1 + } + }, + "2c50e0b4586140f89b5c932f0924d24a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2ce720e250ef4bcc986904febc125b48": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fc0b3426a46844028503ab46da1230fe", + "placeholder": "​", + "style": "IPY_MODEL_48f5b787955e41189e698f9f842d0523", + "value": " 10/10 [00:01<00:00,  7.44it/s, v_num=2, train_loss_step=0.0535, trainDNADiceMetric_step=0.915, val_loss_step=0.053, valDNADiceMetric_step=0.917, val_loss_epoch=0.0572, valDNADiceMetric_epoch=0.911, train_loss_epoch=0.0546, trainDNADiceMetric_epoch=0.915]" + } + }, + "2d4feafdf81144ac9ec7610c6bd7bec5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2e3cf4039bd7412889f96e0f5074d17b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2e4b3d2637214494a1e3144a63f6b2d8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_27960ebdc9b64bfc854a283e2907e11b", + "placeholder": "​", + "style": "IPY_MODEL_29150d9e2a414583870407fcd56e0287", + "value": "Validation DataLoader 0: 100%" + } + }, + "2e608130a04c4799993b4ec2f0027f79": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2ee030af4e5541489a20050aad8efce5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2f1edcd918d446e5bf1c0b48d8ea442f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2f58726958f648ebbadb90e95bbdfdc6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e9add7d8e3534205a85161a1dd8c0561", + "IPY_MODEL_c732b4b99e5e43de98eba24ea9330b8c", + "IPY_MODEL_0a6bc2c7f6cc4af7868ec259cf8e2d10" + ], + "layout": "IPY_MODEL_b462c001fb154c4794053ce3126dd644" + } + }, + "2f65e0c84ad0488589d9099d8857e813": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2fa51f1fbb8b41359089e64ea3d9e709": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4671ae95c7024ac9aef90bde31b1cd5a", + "placeholder": "​", + "style": "IPY_MODEL_54a4b9d97f1f4908871c6410b0372c9d", + "value": " 3/3 [00:00<00:00, 20.21it/s]" + } + }, + "2fa9970eb2344e038499dc2a08791f13": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3083d2e358de4e00a24910dbff9d83d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5d21a03a00ed4c4e8772c1b2aa49036e", + "placeholder": "​", + "style": "IPY_MODEL_c09e5bcfc73a436e8ab8bce80a2f066c", + "value": "Validation DataLoader 0: 100%" + } + }, + "308d296e4c784d5e88bf05985a0a6273": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "30eef8822a3645bda76c1de7866f2d7a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "31a5f2acf0774510a8f94b1dd0c3611f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "31a8648ed6174b3ea0d6cca904f8018c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4a9dadfe582049babf7e91c7d956de55", + "IPY_MODEL_f62028910b1a4e299444705e7795058c", + "IPY_MODEL_26668e33d9dd4d67b39da870b6b26df8" + ], + "layout": "IPY_MODEL_9bda89af8a87453894b70a571544af1e" + } + }, + "31eb075cdf584cfa829bc3f119aa9244": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3250e51e0ed34ad9a8a81354466952bd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3314d1f00dd74034bc28143b99bef726": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "331f64d00dc547d7928e433cd4bffde1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8f0006a1050e49819bfecf9817429c51", + "placeholder": "​", + "style": "IPY_MODEL_5f21fb315ce049e49d37e44aa6adf375", + "value": " 3/3 [00:00<00:00, 22.61it/s]" + } + }, + "333b116b292148699bda35d8da71f3a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3389a58f19334452a8a25dbe5e19f09a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "33c6b24328c341e190273d1ab5d3917a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "33e6c841c0154edbb81d53bf5de15b9a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_07729109119944f9bfdf4bfb15f68e0b", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4d6169d06e3f420abdfe10140b2f1752", + "value": 1 + } + }, + "3515df2d16e14a0284f605d63a48240e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3593ff33dc6a422691e37ae61708a66b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "37b3cad147f74c4397a16ca6883ba98a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ba5d1cdcc089456b81b50d8e9c033bfa", + "placeholder": "​", + "style": "IPY_MODEL_4a34d533b9374b60aec1d1b6e8935014", + "value": "Validation DataLoader 0: 100%" + } + }, + "385582d247594701bf07ea19abcc6961": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3885a42d96a44dfcbd3448c4f32a356f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5911fd23e2c840d9a59cadc4fcdb797d", + "IPY_MODEL_0ea178dd6d3540bd87787328120fd36b", + "IPY_MODEL_db212b22656948d9a190fc4a1a22d139" + ], + "layout": "IPY_MODEL_7b33cc704c9140f195ac96f687d735e9" + } + }, + "38a1154b2af840c2bfa56f98637ee08d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_56e7ad0645874b6697ee7d6058041638", + "IPY_MODEL_8ce63facf77441cf8015139500564c5d", + "IPY_MODEL_c740afa60993457d959de43a861e200d" + ], + "layout": "IPY_MODEL_f3ab972f1ab14fd69d87e7a9af800aaf" + } + }, + "3a5610b41c5f49d78c2e89e23006cfd9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3a923915a02341c8adda26e702a58649": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3ac04713cef64e8cb11d8a4d405726c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3b4b83b841ab45bb9a19e08f52bfc887": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3c1323bad0314e4fa563e498e7bda9f6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3c85353efe9b47888787857596cb1741": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3c8c8708d15d43af8d9a86b752f019c9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9f1ee508f1b0446797118ce36c038fd4", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ac11c98a0f884eabb0111353c01533ed", + "value": 1 + } + }, + "3c9251f3f32a49189ed62cf12908b655": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3cc511d5ba384c10aa8d0d285ae9bc73": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_44500e4704f14a2ba6523013f2f237cb", + "IPY_MODEL_cd2246e275ab4283aea5036a3c083cc3", + "IPY_MODEL_1ba0dee7653247c8b6008c8c60dd40bd" + ], + "layout": "IPY_MODEL_fe23ff3e550a48de82471507e913f733" + } + }, + "3cc8a7fba51942de9e82264e548c62a5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3cde40f339394878b928ec180b8e4e64": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d63a1a9bacb04337b03301301ceed042", + "IPY_MODEL_33e6c841c0154edbb81d53bf5de15b9a", + "IPY_MODEL_975b6c14f7204bd39dcfc6af693c85b1" + ], + "layout": "IPY_MODEL_6df28ba2fc2d46cc8b51f0d80c8ba25d" + } + }, + "3de0b3794ad54c45b7c019cfd285a95e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3e535346524042d1b6d156a73faf2fc9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3e98332b532745d3bbcac8801aae2a31": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "3ee03c10f050486a953717e911d126c8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3eff3edded23414db81879b4c2f6f5b8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_789c4051b78e427c80d9505e4144f46a", + "placeholder": "​", + "style": "IPY_MODEL_90f631a62ce44f6db314bd9cf1451074", + "value": "Validation DataLoader 0: 100%" + } + }, + "3f8d2f2e30e54ea9ac57deca09cb34c8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2902a8dadce1454491f29a01b6655cd3", + "placeholder": "​", + "style": "IPY_MODEL_3515df2d16e14a0284f605d63a48240e", + "value": "Epoch 49: 100%" + } + }, + "3f9b1734cae4441e8e9842e786e3a666": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "40ce8ac2ba224beb9d1cebb9295eae2c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b5ae1f24f1144a99bbae2c07ab050537", + "IPY_MODEL_2c4a4a15fc154209857e5bc221d4a60b", + "IPY_MODEL_7b6afd64da3f49c48f76feb8b75e54dd" + ], + "layout": "IPY_MODEL_604c401384d042eebd72651c36e9b3e5" + } + }, + "412e24ef862f483093195c1c2dad9700": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "413006fb9d2e453abf39cdd4b91caa75": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "4140dfc3649f489dbdb41c85525ea599": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4190b291524948279b199476f5533730": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6438832fe5474201965419106035e40e", + "IPY_MODEL_eb045b2ed03c4f31b6e30f8c54f5e34a", + "IPY_MODEL_14dbde6953364c5c87d9469c49959066" + ], + "layout": "IPY_MODEL_30eef8822a3645bda76c1de7866f2d7a" + } + }, + "425cdf165e3549f592d2c869829a5cfc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d911964788894e79855e0ae47953103a", + "IPY_MODEL_bb4da1ba8c2c47e084597c70e2441a44", + "IPY_MODEL_4d3fad88182241c99d755adf8e5bbb77" + ], + "layout": "IPY_MODEL_efa4351f438740ebb3b555206fe96b6e" + } + }, + "43130a49034c46deb88430a97b67b772": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "43989ff4ef934577b920e58f7458cc0a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "43ad8d40f2104267a64d02c8a4735f42": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3250e51e0ed34ad9a8a81354466952bd", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_709b15f575e2439b914968dce170619a", + "value": 1 + } + }, + "43ce5cc7a3794a9faed7a053c984636e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5955d67a815e42cbbc391fec4784bea1", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_83fa2586801d4cbdac47384f78e906ba", + "value": 1 + } + }, + "44500e4704f14a2ba6523013f2f237cb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_44930c49f41248f38f21e9d23941a1b3", + "placeholder": "​", + "style": "IPY_MODEL_4140dfc3649f489dbdb41c85525ea599", + "value": "Validation DataLoader 0: 100%" + } + }, + "449171807ad14b55876489b49b09bcd8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "44930c49f41248f38f21e9d23941a1b3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "451d8508824949d0ae06c2be42504f7b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4526a155d76542528b553180e2c9f107": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_81671ac2f73b48669e505f454b013dca", + "placeholder": "​", + "style": "IPY_MODEL_a289a2fa75f04aae936662ccd032d70f", + "value": "Validation DataLoader 0: 100%" + } + }, + "4671ae95c7024ac9aef90bde31b1cd5a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "475556f9d2db4569b985192b4648a9bb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "47aded72d1e2424f97dc3426fbff540f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2b2610ec8b884911a15455ebb9f8852b", + "placeholder": "​", + "style": "IPY_MODEL_5429aadaaaaa4767942be28932e6e09a", + "value": "Validation DataLoader 0: 100%" + } + }, + "48333bff75384cf7886c81ca1e3f0056": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "484a5d3a19474d23821c279f602e067d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dbb3626925144fbb9366336171f85a41", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_eadafdb5fc3d4f3b84df9ae41c5854aa", + "value": 1 + } + }, + "48eed094358c4c33a1fec51e83ad1449": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_faa2148c3d1849708c7c61edd90e1291", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7ce09c539e7e43239b274b2951847b4e", + "value": 1 + } + }, + "48f5b787955e41189e698f9f842d0523": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "49a0cb79625a46dc9241a2707a27e52a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8e7e13c148344fcbbe81f9a38bda633b", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1af74cb9bbf24e2e805ca966acbe0907", + "value": 1 + } + }, + "49e5341ae44b43bc887609a461efc80b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4a14a6ec2d3348dcbc9875ec7af4e928": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_53f2f6f68bce41c08df12776081ea727", + "IPY_MODEL_a752a853b6da4c9a867cbc4c356a5f86", + "IPY_MODEL_9f59240c317a4919bced1fea1302825f" + ], + "layout": "IPY_MODEL_17e293d4e9764a2c9336651c5186597c" + } + }, + "4a34d533b9374b60aec1d1b6e8935014": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4a405964924f4527bc988f1679002ea2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4a8debce9ea84992af1a53c9aaa7470d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_199b2ba5fee04882ae0d71a1f06c8c29", + "IPY_MODEL_10bb79a6159545a9a8e1f0a2e1a2cf03", + "IPY_MODEL_93470f3024cc4db09420bcf82df30ed0" + ], + "layout": "IPY_MODEL_b9b5f84e0ad04dfdaa801aae0759b7c8" + } + }, + "4a9dadfe582049babf7e91c7d956de55": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7b10ca1619e948dd91248c7ec8b075ef", + "placeholder": "​", + "style": "IPY_MODEL_eabdb0f39f1f43cf8f5e37b2abfc279f", + "value": "Validation DataLoader 0: 100%" + } + }, + "4aec1986363b4a899ff12c1670eb99d4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4ba6608f281b443094cd1a057fc56edf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f110be5d117b49ffb8f696ebeb44fd54", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9ebee1344386470abd6ecb7c73c114e8", + "value": 1 + } + }, + "4c5db6fbb19943c19b6a91c9ebb72227": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4cb23d2da234483fab7b0d292aae77d6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4cc3497b5dca4bb092237b8dbef8cb8f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4d3fad88182241c99d755adf8e5bbb77": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8e6caa11df7d40c880506ce1587d3080", + "placeholder": "​", + "style": "IPY_MODEL_03d29d4401344338a1bc1e840b8a8208", + "value": " 3/3 [00:00<00:00, 22.38it/s]" + } + }, + "4d504ee7c6074c64960523a855043fbc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ad94f07de5fd480c95d444bf89488537", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fa210271474f4e82bb4d087e1ffeee4f", + "value": 1 + } + }, + "4d6169d06e3f420abdfe10140b2f1752": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4e0c287d06814086b4c1b478fb11dfe5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4e4b06c04fb9400b9a89aacaa0b1926a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0c1de1c66eed49ad826796f167c875fe", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9313d0d4d0794c448c119cb081eeefd8", + "value": 1 + } + }, + "4f64f33ec76545669aad6cad0532bf52": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fe72db6203cc472695e2217021d84b33", + "IPY_MODEL_a4a766bb527240aca3846cb63d9f1e1b", + "IPY_MODEL_682e08c8af3247b8b01a31a113920e4f" + ], + "layout": "IPY_MODEL_904dd3a3be60473c91575ed0105bec04" + } + }, + "4fb03babee474f98bc3f153b930c3973": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4fd7a055897d495da333b612468f50d3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2247bf9c5e134d28ac140fa9947cbadd", + "placeholder": "​", + "style": "IPY_MODEL_7b312daa8c8d4f4693a43fb24c9167a7", + "value": " 3/3 [00:00<00:00, 23.55it/s]" + } + }, + "50ac65735b464186a73dd287df8bdb90": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "51a977e26e3246c0bb2f6e079a06a7bc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_174d67b232ac40d695cb15665959ac0c", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8a991636ec0d4514973402ce7942f200", + "value": 1 + } + }, + "51de3b840a3344c8b1131aa08d0c48af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_18d30486f46544ba947954cad0897d53", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_5887ca685a454f069902494c857eff62", + "value": 1 + } + }, + "524439135fb54e3ba86f5ace4eb06338": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b0133d98440d4496995d89a6c3d24a9c", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_81bbb203f78c4e9ca03bae7163d04459", + "value": 1 + } + }, + "52db1d1561db4f5ca9b881ff55320251": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_92b11b42862d464fa908abaeb6a2e437", + "placeholder": "​", + "style": "IPY_MODEL_a1003fa3bcb249b886cfc6a7fb50f3b7", + "value": "Validation DataLoader 0: 100%" + } + }, + "53514d6c6a5747c781da5d5731076fa3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "53f2f6f68bce41c08df12776081ea727": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ece37dfc7f7846089b7ae9f620da5590", + "placeholder": "​", + "style": "IPY_MODEL_6849f7fa0d6f41ab9c8a3fafadd166b1", + "value": "Validation DataLoader 0: 100%" + } + }, + "5429aadaaaaa4767942be28932e6e09a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "54a4b9d97f1f4908871c6410b0372c9d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "54afe3c681fd4869b5cc34d9aa410881": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "556e1708cb714b7ca1f24dbcc30845cb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "55ebce6aedaf44569ebe813c11d86db0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "561247266aca4a06a29ca8d77d5390f1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "561482bb8bda448b8ac9f924ebac2c49": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "561adb0dc1c943e6ac7734d9d214f35a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "56399d46ad8b44ed8ed0adf329893522": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "5671f7eaab934f108a1202ab876c0da9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "56b57990ab094da3accd27ee807e9a92": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_680893a87c164913972e227461e4853c", + "IPY_MODEL_175aa4436adf4ba699b550ec31f13f8c", + "IPY_MODEL_e4e08a2301f6407eb5cc13c15102efe6" + ], + "layout": "IPY_MODEL_5b2c06adca494ad8b235031e32e3d769" + } + }, + "56ddb3c87b764bdc96a118235ed5c1e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_12f90753525d4938bd9ccdd3affdf222", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_bedfd3bf09594024adfbcc6c76b3d120", + "value": 1 + } + }, + "56e7ad0645874b6697ee7d6058041638": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_917afa78da954d1e8ad09dd4cf9f4202", + "placeholder": "​", + "style": "IPY_MODEL_0ae94f04037447acb216044112f9175b", + "value": "Validation DataLoader 0: 100%" + } + }, + "5729ea76ec2b4c9eb3f5143f3e5b0a60": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_db7f36c1229c472bbfca23cfc260f4c5", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_77babc7cce66414b87aa437610eb4bd5", + "value": 1 + } + }, + "57a0365d6e264988a9f8340c13cb32ac": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "58034176a80143809a8dfc91a9a3aff3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "586ca83e63894831b02c18cd6d50ac67": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_246b3248809140ce93eb13901bed3892", + "placeholder": "​", + "style": "IPY_MODEL_31eb075cdf584cfa829bc3f119aa9244", + "value": "Validation DataLoader 0: 100%" + } + }, + "5887ca685a454f069902494c857eff62": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5911fd23e2c840d9a59cadc4fcdb797d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7ae860cacde943d9b40ce530f3de23e7", + "placeholder": "​", + "style": "IPY_MODEL_2d4feafdf81144ac9ec7610c6bd7bec5", + "value": "Validation DataLoader 0: 100%" + } + }, + "5955d67a815e42cbbc391fec4784bea1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "59b6ed718ae547519a7520bd0ba8cff6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "59e61b3b77174b06a86e04d5ebda5703": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8a3f0120a932480fabd5df4bab19b4ee", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_bfe5ecfb0f4c402ca61d4c401882c29f", + "value": 1 + } + }, + "5a20ac379047420483e2e3c281846da8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5a8d30cc9ab2422094515bd3fa829cf0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5ae95da99ca04dd899c2e10cfcb1a4b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5b2c06adca494ad8b235031e32e3d769": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "5c2bdf30acb64fde97964052bf1158ea": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5c49200354514c20bdb71fedbcf634a2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5c6215db50ab462388024533bc764d6c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b6f83849585749c9851b2eb021d99f97", + "placeholder": "​", + "style": "IPY_MODEL_2f65e0c84ad0488589d9099d8857e813", + "value": " 3/3 [00:00<00:00, 23.46it/s]" + } + }, + "5c9b296e4e2248bd80b763abfa0d3aa9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_67091d0ab8274792a1ee046e7d5ba315", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4c5db6fbb19943c19b6a91c9ebb72227", + "value": 1 + } + }, + "5ce8d4f4ca734748adf31e8a5328a430": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5d09e24e29e94a9493293cb44f2f05ed": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5d116e6c9d944632a0bb3667425ce1fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2e4b3d2637214494a1e3144a63f6b2d8", + "IPY_MODEL_48eed094358c4c33a1fec51e83ad1449", + "IPY_MODEL_331f64d00dc547d7928e433cd4bffde1" + ], + "layout": "IPY_MODEL_b2f473ff0fdf49698f439d63ad6e6954" + } + }, + "5d11defaa1624b83a8a47e4745a13d7a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5d21a03a00ed4c4e8772c1b2aa49036e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5d24e35625b1440fb3e0254d16762b22": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_80f20c8f2c1948c69cd779e36f7066c7", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_5ae95da99ca04dd899c2e10cfcb1a4b7", + "value": 1 + } + }, + "5d57d4c3e3a24cac8a8ab228b199ca22": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5d738cc2fe5447cb89f343a31554e050": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5e923969e34848c6851b2b03c7b41841": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "5ee267ba68f04f27a4d44ac895c28be4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5f21fb315ce049e49d37e44aa6adf375": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5f8819ebd06e4a3f8dab4a84855019dd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "60102f86fd2742cdb8c73a720c558b21": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "604c401384d042eebd72651c36e9b3e5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "6113dfc521c64c89abc5c0a20499381f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6178e85c32c64115bd3105cd74efed18": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4fb03babee474f98bc3f153b930c3973", + "placeholder": "​", + "style": "IPY_MODEL_22ad0c58d4a94b469e15b425c20edb60", + "value": " 3/3 [00:00<00:00, 23.36it/s]" + } + }, + "61bdef04eaff450ca8d552b7ebc67533": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_08147947751240079f5d4fc1ebb3d2a8", + "IPY_MODEL_656ec0e3fc91481bb1fbd3aec5c9f007", + "IPY_MODEL_f3c46fae7ba04122b9ea6721d3fd59f9" + ], + "layout": "IPY_MODEL_65af6aa005304854b289c94d562ee42c" + } + }, + "61c1424c837a411d91e1e361e2f663fb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4cb23d2da234483fab7b0d292aae77d6", + "placeholder": "​", + "style": "IPY_MODEL_cfddec8a651f495397214b49f9b8091d", + "value": "Validation DataLoader 0: 100%" + } + }, + "631e42e29fa24b01bdf65a52c5a3789e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_134eb7ee8cc64f68be7803f5d10e415c", + "placeholder": "​", + "style": "IPY_MODEL_a136e3374ce04534a06061f743d710d5", + "value": " 3/3 [00:00<00:00, 22.02it/s]" + } + }, + "6348038c38224d04af7bf57abedabec9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_96a3c2562f2e4d97b8e11bfea7092ad1", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e51e2fae2577476eb17a5589654e4146", + "value": 1 + } + }, + "6390e224619346a8af81a12030c7fb38": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_72299ab304f54db1a02a56f0d4c0ec54", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_aa0d6cf2f28040c19305a9704740ec23", + "value": 1 + } + }, + "6438832fe5474201965419106035e40e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3314d1f00dd74034bc28143b99bef726", + "placeholder": "​", + "style": "IPY_MODEL_7e095acd45294cd499418a6dc525ac28", + "value": "Validation DataLoader 0: 100%" + } + }, + "6469faa7ce30401c8406ace5479d0744": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6513da4ffafb4d01b5c487ac7cf931ae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b40b9defd0e54112a478434d87f3d37c", + "IPY_MODEL_afa45e41b7894012966afdceddbdcef9", + "IPY_MODEL_203d55b28e7b4c12940f1af7e0fb5fcd" + ], + "layout": "IPY_MODEL_907e7eeceda44049b47167d5772392d8" + } + }, + "656ec0e3fc91481bb1fbd3aec5c9f007": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9a70f8e5d1b345bda0c4aecf39e26596", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_5ee267ba68f04f27a4d44ac895c28be4", + "value": 1 + } + }, + "65af6aa005304854b289c94d562ee42c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "66a4a0681ee44eff8f045b7a385cd1a2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "67091d0ab8274792a1ee046e7d5ba315": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "671faaa6260e4b6687d39e69951d7764": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_37b3cad147f74c4397a16ca6883ba98a", + "IPY_MODEL_f977f92cd00040b79d1370265c355470", + "IPY_MODEL_7ee7fbcfa28f4708b85d4721945a34c6" + ], + "layout": "IPY_MODEL_2426adb29a43459895b1f5192654b6ec" + } + }, + "678a690a7ede408fbd504364e0515db1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_705032b0be3741eb8d9f4cc9d3842feb", + "IPY_MODEL_5729ea76ec2b4c9eb3f5143f3e5b0a60", + "IPY_MODEL_5c6215db50ab462388024533bc764d6c" + ], + "layout": "IPY_MODEL_475556f9d2db4569b985192b4648a9bb" + } + }, + "67c16e3db25c47b581acbe130118fbb9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1c19b3d200d14671994983a2b480d525", + "placeholder": "​", + "style": "IPY_MODEL_9fe0c115193a46c2839b7dba4930ab81", + "value": " 3/3 [00:00<00:00, 23.17it/s]" + } + }, + "67da59c080324e948eeb07890d5ee9da": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_73a668df55a54615ba5bffc804be35af", + "IPY_MODEL_e80004eab2b54b4eafcfab7c2dec94d9", + "IPY_MODEL_2701cb8cf0b64ae0b15efe9c0e32dd01" + ], + "layout": "IPY_MODEL_bb444ac91bbf4b91883b5ccd40b6bd41" + } + }, + "680893a87c164913972e227461e4853c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cf72bf7126a24a8281cfc4ff0dac558b", + "placeholder": "​", + "style": "IPY_MODEL_59b6ed718ae547519a7520bd0ba8cff6", + "value": "Validation DataLoader 0: 100%" + } + }, + "682e08c8af3247b8b01a31a113920e4f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c33091d26af94d4f849426d89604efc6", + "placeholder": "​", + "style": "IPY_MODEL_bd210a7aa7724c048560040debfbd7f6", + "value": " 3/3 [00:00<00:00, 17.27it/s]" + } + }, + "6849f7fa0d6f41ab9c8a3fafadd166b1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "68fdb591245f4e2d9df83514d7d5e6bb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "691e3d84fe9642f592bc6621df965af6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "691fc75d0196480c94281c9f8c4e4444": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6942c1a729a14fb7823c10209797414f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6a5a24e536314b55952f3ee2d8719970": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6a703a473224472f9f300236fc25bbe1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "100%" + } + }, + "6a9cab5ce8ff43b3a57c47931d4c1cc8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6b89e0a40f934cd78aa670de2bbc7158": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6bfbb82616da41e6aa398500f81eb7b5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_030b37cea4ba414db5fae6384ed6cdb6", + "placeholder": "​", + "style": "IPY_MODEL_f73f08cd498a47eaa01b6ee3e0a9d288", + "value": "Validation DataLoader 0: 100%" + } + }, + "6c3a98e141ef41ebac5033241e901a0a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6cb7b43df77648d39950587fb4839546": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6daa75d66b5e4ae9a248ca81f9a973c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cdeb0f7de79e4f06b4c76d92d276cb20", + "placeholder": "​", + "style": "IPY_MODEL_72d85446467f44819931d0fc1ef388ca", + "value": " 3/3 [00:00<00:00, 23.28it/s]" + } + }, + "6daeec99a0ec4247b33fcc5424cdf2b1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3f8d2f2e30e54ea9ac57deca09cb34c8", + "IPY_MODEL_084e9fa8a9924883ab4de7f6ff398d69", + "IPY_MODEL_2ce720e250ef4bcc986904febc125b48" + ], + "layout": "IPY_MODEL_6a703a473224472f9f300236fc25bbe1" + } + }, + "6df28ba2fc2d46cc8b51f0d80c8ba25d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "6e2e3c6c871342c883141e0314353e37": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "6e366f2178ab48519debac50a89d8b9f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8819541346574b2f9b8ad66a924f66a0", + "IPY_MODEL_484a5d3a19474d23821c279f602e067d", + "IPY_MODEL_6daa75d66b5e4ae9a248ca81f9a973c4" + ], + "layout": "IPY_MODEL_d43d30e849b048c5b038c0ea28051a29" + } + }, + "6e5f2583b8cc4cc8a1218f2c2bec6297": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_449171807ad14b55876489b49b09bcd8", + "placeholder": "​", + "style": "IPY_MODEL_eccaed078ac547328383e1fb8c8422bd", + "value": " 3/3 [00:00<00:00, 19.25it/s]" + } + }, + "6e8070d424684b45bc2d2452edfd1ca6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6f152e50ae2e433aa01bf9820764022c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6f5f7d72f10c42f2a13a4e330cd1d96d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6f6933d25b4147a288c1142f8aa49e24": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "705032b0be3741eb8d9f4cc9d3842feb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_138d51e2eee64063b8347d75eb3002e5", + "placeholder": "​", + "style": "IPY_MODEL_385582d247594701bf07ea19abcc6961", + "value": "Validation DataLoader 0: 100%" + } + }, + "709b15f575e2439b914968dce170619a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "712feb908f5045e39b75f7123bb7dbf6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_50ac65735b464186a73dd287df8bdb90", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8ad023a1d4414a33bf73eaf801cbd3c4", + "value": 1 + } + }, + "7144eb829e304795b3a54362a2d3308d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "719b5325829f44caa738198d8d8919e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2e608130a04c4799993b4ec2f0027f79", + "placeholder": "​", + "style": "IPY_MODEL_2c50e0b4586140f89b5c932f0924d24a", + "value": " 3/3 [00:00<00:00, 21.71it/s]" + } + }, + "719c2567f6c143f2bd88659fdbc158fb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7e8401965c3e4bce8c7c03f927e647b7", + "placeholder": "​", + "style": "IPY_MODEL_2b88126853b94cf085854107c124e754", + "value": "Sanity Checking DataLoader 0: 100%" + } + }, + "72299ab304f54db1a02a56f0d4c0ec54": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "72823355de9044eba020e56ffe2d3865": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_87dd9bcece474721b57d651815d4115a", + "IPY_MODEL_80202dea9db64ae7987c220a85a7dcac", + "IPY_MODEL_6178e85c32c64115bd3105cd74efed18" + ], + "layout": "IPY_MODEL_0eaa81e3e1d443c387792ee6e64fd1b6" + } + }, + "72d85446467f44819931d0fc1ef388ca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "73622e0503054ee4aa0a851c245eb607": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0eca4509b4a94446874ac1614104642b", + "IPY_MODEL_1a6d7e044bf341b88232922836650fef", + "IPY_MODEL_d5ef045581f049caa9d79f10907e526a" + ], + "layout": "IPY_MODEL_02349ea7bced4c8186933cd0134487f2" + } + }, + "73a668df55a54615ba5bffc804be35af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9cce801e24c147cea6eb4861b5a55987", + "placeholder": "​", + "style": "IPY_MODEL_885eba97a8bd4006ae9cc9994724c6a8", + "value": "Validation DataLoader 0: 100%" + } + }, + "743dd24c3e314c0590a187f1166bc10e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_da1ce1311a7a49a9b83bd4b6edeb6f98", + "placeholder": "​", + "style": "IPY_MODEL_6e8070d424684b45bc2d2452edfd1ca6", + "value": "Validation DataLoader 0: 100%" + } + }, + "74f2bc8b9aee4fc9986ed0e6d833bab3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7501155baee5472f9140ac1e04845f75": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "77a3ae393cd54d0f90573d4b2f962c6c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "77babc7cce66414b87aa437610eb4bd5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "783b37e7224247b5ad69a3a9fe83cab0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7861c5c2fdc54fcd8f3cfb26be5f4dc5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_47aded72d1e2424f97dc3426fbff540f", + "IPY_MODEL_ebbf3193c2ea4b7d98d8504af04bb7e1", + "IPY_MODEL_c9899780726f453b8ef79792b92576cc" + ], + "layout": "IPY_MODEL_6e2e3c6c871342c883141e0314353e37" + } + }, + "789c4051b78e427c80d9505e4144f46a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "79bee0ed60c84ba5aea9f9f0b1314031": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a097f30c0c204cb9924d6f6bdd709cbe", + "IPY_MODEL_4e4b06c04fb9400b9a89aacaa0b1926a", + "IPY_MODEL_1d903dbd3c9c4f059e5f539cb8d49e80" + ], + "layout": "IPY_MODEL_d83d719827dc4cf18fd6b4be1a013b48" + } + }, + "7a37a6630f874ef1af76b2c89f6fe269": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "7a860c9a51884bc28dbc95be3a5eff52": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_743dd24c3e314c0590a187f1166bc10e", + "IPY_MODEL_6348038c38224d04af7bf57abedabec9", + "IPY_MODEL_e77db813dca54e869bea4a928040769a" + ], + "layout": "IPY_MODEL_101ae0ce1af94c45a5f01989c271074d" + } + }, + "7ae73c7bbf9f4dc7bc28d31f17f6d5d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7ae860cacde943d9b40ce530f3de23e7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7b10ca1619e948dd91248c7ec8b075ef": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7b312daa8c8d4f4693a43fb24c9167a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7b33cc704c9140f195ac96f687d735e9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "7b6afd64da3f49c48f76feb8b75e54dd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d93a2657edec4e23a50f067465192ee6", + "placeholder": "​", + "style": "IPY_MODEL_561247266aca4a06a29ca8d77d5390f1", + "value": " 3/3 [00:00<00:00, 22.38it/s]" + } + }, + "7be149c51b0b4709b53a97c054ee154d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "7bea23ddd64f4b229e869423fca4a3fa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7c8de7d0ad144b64bbfff2d0851c9ff2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7cb62ceb722f4d38b9c5d80b32b0841a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ec1864db512149518a1b0cbbbab057d6", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_bbfe385d70f84c3fa7c22e04a4faa8a3", + "value": 1 + } + }, + "7ce09c539e7e43239b274b2951847b4e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7d6da8d8ded148e7958e1b747424828a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7e095acd45294cd499418a6dc525ac28": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7e8401965c3e4bce8c7c03f927e647b7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7eaa8bd25f384c9a8ba7fb6faed6b3f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7ec6252e85764215b7b94d323aeba6d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7ee7fbcfa28f4708b85d4721945a34c6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0b0b8dfdf0054425b83e8a4994acc8fc", + "placeholder": "​", + "style": "IPY_MODEL_7ec6252e85764215b7b94d323aeba6d6", + "value": " 3/3 [00:00<00:00, 23.64it/s]" + } + }, + "7ef0a9a688f447a98ef9341b72b1a6ba": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "800b1826eb8a4fac98702973a4329c9b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c8f695256a574888af49e942ff0d53ea", + "placeholder": "​", + "style": "IPY_MODEL_783b37e7224247b5ad69a3a9fe83cab0", + "value": " 3/3 [00:00<00:00, 23.19it/s]" + } + }, + "80202dea9db64ae7987c220a85a7dcac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ce568ae8b1bd4bc28cea074e0a295ef0", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d2232ad66e614f79aa31dacb583eac7e", + "value": 1 + } + }, + "80b7e2aa713a45ca9c2bf8eae7d6bb4d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "80f20c8f2c1948c69cd779e36f7066c7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "81671ac2f73b48669e505f454b013dca": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "819b4436cf3548f29ac4d5ed3fb45eb8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "81bbb203f78c4e9ca03bae7163d04459": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "827ab09eb5244faaa2bb7737bc38a662": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0d0222a098a24c4db6e99d2e3f0921ad", + "IPY_MODEL_59e61b3b77174b06a86e04d5ebda5703", + "IPY_MODEL_8874086714df499886c05cfaf1202ff1" + ], + "layout": "IPY_MODEL_215a7a11baf44b5782096bc13d88a0be" + } + }, + "83fa2586801d4cbdac47384f78e906ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "84d2ca2125194162937cd60d202efee3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "84deef98024b48efb3f18fae1ee3dffc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "851f40556b6545f1b2e8b2c49d1f3a24": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "8543f611eeb1412bad6d60f9188daa72": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_899083680c9848b4879aebd89f447fc8", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_cd7c7e091fc24d328e550c0c49fc3a8a", + "value": 1 + } + }, + "87dd9bcece474721b57d651815d4115a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5c49200354514c20bdb71fedbcf634a2", + "placeholder": "​", + "style": "IPY_MODEL_9546adf443cb47cea6d50a2c4f24fd85", + "value": "Validation DataLoader 0: 100%" + } + }, + "88123fd47960496e989711120607b605": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8819541346574b2f9b8ad66a924f66a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_14907f787b0b4e1da4a252d16f1928f9", + "placeholder": "​", + "style": "IPY_MODEL_a0ab8aa511344baf879297df64c2f9fc", + "value": "Validation DataLoader 0: 100%" + } + }, + "885eba97a8bd4006ae9cc9994724c6a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8874086714df499886c05cfaf1202ff1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d8dea74096e64878b237c0a851aac991", + "placeholder": "​", + "style": "IPY_MODEL_e34bdd70106343a5b8612b488b0113f6", + "value": " 3/3 [00:00<00:00, 22.04it/s]" + } + }, + "890891d40cbd42c19ac36100fd39b3c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7144eb829e304795b3a54362a2d3308d", + "placeholder": "​", + "style": "IPY_MODEL_3c9251f3f32a49189ed62cf12908b655", + "value": "Validation DataLoader 0: 100%" + } + }, + "899083680c9848b4879aebd89f447fc8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8a3f0120a932480fabd5df4bab19b4ee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8a991636ec0d4514973402ce7942f200": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8ad023a1d4414a33bf73eaf801cbd3c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8b28746752804efb9514a943d1eaaa40": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_719c2567f6c143f2bd88659fdbc158fb", + "IPY_MODEL_4d504ee7c6074c64960523a855043fbc", + "IPY_MODEL_b0a7821cc80b4d3085d0e3ed5722edd5" + ], + "layout": "IPY_MODEL_a90137b5afbb4831a319bd707ae66e55" + } + }, + "8cba9c6709e5454ea15349dc42cfe0cd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8cc548cea0c247d4ae5ab1eeed9cc475": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8ce63facf77441cf8015139500564c5d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_43989ff4ef934577b920e58f7458cc0a", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e813e4725c4a43adba6363b551246f61", + "value": 1 + } + }, + "8d6de7a9be714081a8e1369deb51dee6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_256268cbec374eae90521d3b14c86c9f", + "placeholder": "​", + "style": "IPY_MODEL_918c0123e33f453fa046d906e31191f7", + "value": "Validation DataLoader 0: 100%" + } + }, + "8e6a75869f2f4ac5a531530b43b40718": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_02deb853ae5945098b5c1598e0782932", + "placeholder": "​", + "style": "IPY_MODEL_3f9b1734cae4441e8e9842e786e3a666", + "value": " 3/3 [00:00<00:00, 23.41it/s]" + } + }, + "8e6caa11df7d40c880506ce1587d3080": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8e7e13c148344fcbbe81f9a38bda633b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8e84599c746a4d149d3f8930f2fab49d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8f0006a1050e49819bfecf9817429c51": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8f76fcea6a0a45d1af4d5e4985ababda": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "904dd3a3be60473c91575ed0105bec04": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "907e7eeceda44049b47167d5772392d8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "90f631a62ce44f6db314bd9cf1451074": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "917afa78da954d1e8ad09dd4cf9f4202": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "918c0123e33f453fa046d906e31191f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "921a4b00691a4346b04ee18dda85fe9c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "92b11b42862d464fa908abaeb6a2e437": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9313d0d4d0794c448c119cb081eeefd8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "93470f3024cc4db09420bcf82df30ed0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_412e24ef862f483093195c1c2dad9700", + "placeholder": "​", + "style": "IPY_MODEL_333b116b292148699bda35d8da71f3a8", + "value": " 3/3 [00:00<00:00, 23.96it/s]" + } + }, + "945010c321a84e41828d564ccd6cab17": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_58034176a80143809a8dfc91a9a3aff3", + "placeholder": "​", + "style": "IPY_MODEL_556e1708cb714b7ca1f24dbcc30845cb", + "value": "Validation DataLoader 0: 100%" + } + }, + "94b0542bd9a24f47829d80d75e9e6caf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "94de6e1f0dc54520b8bf96bec4599f9a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6bfbb82616da41e6aa398500f81eb7b5", + "IPY_MODEL_6390e224619346a8af81a12030c7fb38", + "IPY_MODEL_0f6cde3fd35f4bf7ad1e8b22a2915a29" + ], + "layout": "IPY_MODEL_277bc910427c41c09786efadfb15e973" + } + }, + "9504247d6ca649aea2ef4ad828f523a6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9546adf443cb47cea6d50a2c4f24fd85": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "962668142d9b497db0704cbc10129a80": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "966280e648174531853430b876c96b3e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "96a3c2562f2e4d97b8e11bfea7092ad1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "975b6c14f7204bd39dcfc6af693c85b1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_43130a49034c46deb88430a97b67b772", + "placeholder": "​", + "style": "IPY_MODEL_2e3cf4039bd7412889f96e0f5074d17b", + "value": " 3/3 [00:00<00:00, 18.80it/s]" + } + }, + "97cdd8befbe4449f9a005e3b33848f00": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8d6de7a9be714081a8e1369deb51dee6", + "IPY_MODEL_56ddb3c87b764bdc96a118235ed5c1e1", + "IPY_MODEL_f5bdab9255224de7ae62b4c83169c022" + ], + "layout": "IPY_MODEL_68fdb591245f4e2d9df83514d7d5e6bb" + } + }, + "995eb88c1ce5422b83ec25f99a059bb0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_308d296e4c784d5e88bf05985a0a6273", + "placeholder": "​", + "style": "IPY_MODEL_996b3a00f07045c48d80011f2f6bf295", + "value": " 3/3 [00:00<00:00, 17.59it/s]" + } + }, + "996b3a00f07045c48d80011f2f6bf295": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9a367b91d3fb40699363c94d40a21c7c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9a70f8e5d1b345bda0c4aecf39e26596": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9bda89af8a87453894b70a571544af1e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "9c0cb0386434437681770e99b0db0744": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6a9cab5ce8ff43b3a57c47931d4c1cc8", + "placeholder": "​", + "style": "IPY_MODEL_bf19184bcfd74fd6a01f0e791d4b1bb9", + "value": " 3/3 [00:00<00:00, 24.10it/s]" + } + }, + "9cce801e24c147cea6eb4861b5a55987": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9d7149c5a5174b5da388a5898036e8af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9ebee1344386470abd6ecb7c73c114e8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9f1ee508f1b0446797118ce36c038fd4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9f59240c317a4919bced1fea1302825f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2f1edcd918d446e5bf1c0b48d8ea442f", + "placeholder": "​", + "style": "IPY_MODEL_9fe43efc7832435a91ce56ba8c6b0e71", + "value": " 3/3 [00:00<00:00, 22.88it/s]" + } + }, + "9fe0c115193a46c2839b7dba4930ab81": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9fe43efc7832435a91ce56ba8c6b0e71": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a097f30c0c204cb9924d6f6bdd709cbe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cc5789103b634ea091fe10e89a0fa387", + "placeholder": "​", + "style": "IPY_MODEL_1c7fe430ec1147afabbc3b8f2733595f", + "value": "Validation DataLoader 0: 100%" + } + }, + "a0ab8aa511344baf879297df64c2f9fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a1003fa3bcb249b886cfc6a7fb50f3b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a136e3374ce04534a06061f743d710d5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a1478fa6b5ce4aa9bd0ccee4c50602f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_57a0365d6e264988a9f8340c13cb32ac", + "placeholder": "​", + "style": "IPY_MODEL_03e87b2770764a44b0fb60c69940fa8a", + "value": " 3/3 [00:00<00:00, 17.11it/s]" + } + }, + "a1b8f183134e41c3969882b651876c05": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a227c49da5464a3db3817b29583b19a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f45de29667c64d98a6d84e5fc642c631", + "IPY_MODEL_cc1285bdc1a74576929e696b39cdff32", + "IPY_MODEL_c11a0b4153bb41229b54f2c316e49fb6" + ], + "layout": "IPY_MODEL_e0b7aafcb493493eb7cc38dcc2e7e790" + } + }, + "a240a470cabe4ec5aba95cbec336c87f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a289a2fa75f04aae936662ccd032d70f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a2a5801a03eb4c488bea54a303de8aa8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a3c33f5a9a25492aa0e775ed7afe26f2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a3e103155f8048798c0ac10a88493730": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e4fa28df40184fef85979ecf49eb0227", + "IPY_MODEL_8543f611eeb1412bad6d60f9188daa72", + "IPY_MODEL_d5cfe8ba6de44341a3a93ad3a4453def" + ], + "layout": "IPY_MODEL_0a5c47146e3841d7826ec9f9ebc4ebaf" + } + }, + "a4a766bb527240aca3846cb63d9f1e1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6f5f7d72f10c42f2a13a4e330cd1d96d", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c65cc31b212940c09f11ceb11c222ef4", + "value": 1 + } + }, + "a52384c27ba84d7ea578c9b8973931f7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a66f018d98b043a69b1877d53170c040": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a6b98b78fc9c4106be98cc9c76420e45": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_08050b72b51745a0bb4a6db7eee67474", + "IPY_MODEL_51de3b840a3344c8b1131aa08d0c48af", + "IPY_MODEL_fa8df0bc1a3d4b469ee5f3d25a0f92d2" + ], + "layout": "IPY_MODEL_e2a9cc1c6dea443ca1aa1841fa3fce5a" + } + }, + "a73eb569400d41ff84133f7c31197f10": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a752a853b6da4c9a867cbc4c356a5f86": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cf90653728a544029afdf0d285db1b71", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_14dfa39560914f5e9269e122d47adcfa", + "value": 1 + } + }, + "a7e7f2bcb26848f09f12b01bc1820c98": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a90137b5afbb4831a319bd707ae66e55": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "aa0d6cf2f28040c19305a9704740ec23": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ab2dcf296209485aa2bdcc204e782715": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "ac11c98a0f884eabb0111353c01533ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "acbd9aa0859342e19a0e0ce928d6ad05": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ad94f07de5fd480c95d444bf89488537": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ae7f89fa88e4492e8d47b8c7592c1271": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_53514d6c6a5747c781da5d5731076fa3", + "placeholder": "​", + "style": "IPY_MODEL_6113dfc521c64c89abc5c0a20499381f", + "value": "Validation DataLoader 0: 100%" + } + }, + "aee41a66745047fba6a396645a7b8ad2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "afa45e41b7894012966afdceddbdcef9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a7e7f2bcb26848f09f12b01bc1820c98", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_77a3ae393cd54d0f90573d4b2f962c6c", + "value": 1 + } + }, + "afbf370d7070420baad9e7ce8b643456": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b0133d98440d4496995d89a6c3d24a9c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b068791a98704c6e8ab258319dad8263": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b0a7821cc80b4d3085d0e3ed5722edd5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3a5610b41c5f49d78c2e89e23006cfd9", + "placeholder": "​", + "style": "IPY_MODEL_b9787a3252ca42b2a28072694afa7def", + "value": " 2/2 [00:00<00:00, 23.01it/s]" + } + }, + "b0f4c8fb387e489b942f9f0d6ae7d8ea": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "b1eabe6afaab4879b4e60b75a13c53f2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b224a2ff47304317af4868ac6370ffbd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b2f473ff0fdf49698f439d63ad6e6954": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "b30a5a9d17284e919da9c824022469c0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b40b9defd0e54112a478434d87f3d37c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2968cd77eaac49d09fc69844d62d533e", + "placeholder": "​", + "style": "IPY_MODEL_24107da359a7483c83160459daa1091c", + "value": "Validation DataLoader 0: 100%" + } + }, + "b462c001fb154c4794053ce3126dd644": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "b560e10add5d49dc875984178fb6c6bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_586ca83e63894831b02c18cd6d50ac67", + "IPY_MODEL_49a0cb79625a46dc9241a2707a27e52a", + "IPY_MODEL_67c16e3db25c47b581acbe130118fbb9" + ], + "layout": "IPY_MODEL_b0f4c8fb387e489b942f9f0d6ae7d8ea" + } + }, + "b5ae1f24f1144a99bbae2c07ab050537": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cb153aa133b14ab08dfa44caeeb6b81e", + "placeholder": "​", + "style": "IPY_MODEL_1119633b9b7f45bcb9274237898ae999", + "value": "Validation DataLoader 0: 100%" + } + }, + "b65b184f71e5418299c8c15f2982e874": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b673982fde464818902b9d9188682521": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_036e4baeb0f84146aad777ed9987dbdb", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f148afd0ea3a4625a3600fc67c3693ff", + "value": 1 + } + }, + "b6f83849585749c9851b2eb021d99f97": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b8ff4c15bd8b404d8eba17d813f5a423": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b9787a3252ca42b2a28072694afa7def": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b9b5f84e0ad04dfdaa801aae0759b7c8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "ba5d1cdcc089456b81b50d8e9c033bfa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bb444ac91bbf4b91883b5ccd40b6bd41": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "bb4da1ba8c2c47e084597c70e2441a44": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4a405964924f4527bc988f1679002ea2", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b8ff4c15bd8b404d8eba17d813f5a423", + "value": 1 + } + }, + "bbc25d75785846ebadf149ac3bc399e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c24c9d09c1ff4c4497c11e087cb74601", + "IPY_MODEL_eecb9deb211c43c7b99d28a147d64574", + "IPY_MODEL_f909105afa944e23a3bd7448050b8e24" + ], + "layout": "IPY_MODEL_dd7333bf31cb4da9b0cbe872d706569b" + } + }, + "bbfe385d70f84c3fa7c22e04a4faa8a3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bc896c2b5a674b58a8f4297c86335e6c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6cb7b43df77648d39950587fb4839546", + "placeholder": "​", + "style": "IPY_MODEL_3ac04713cef64e8cb11d8a4d405726c4", + "value": "Validation DataLoader 0: 100%" + } + }, + "bc93eb10d7f44b559d17c6b5c6cb93b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1088c60e62f64798b702028799231729", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6b89e0a40f934cd78aa670de2bbc7158", + "value": 1 + } + }, + "bd210a7aa7724c048560040debfbd7f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bd24262a245b4a8fa786bc8a172e64d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bedfd3bf09594024adfbcc6c76b3d120": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bf19184bcfd74fd6a01f0e791d4b1bb9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bf97514daefb48869a318e5e617483a1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d0fe8f14840146df9fc769f2ffc6f103", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1dc882f2764548e1a1103da0a7d4052a", + "value": 1 + } + }, + "bfe5ecfb0f4c402ca61d4c401882c29f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c09e5bcfc73a436e8ab8bce80a2f066c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c0c48b257aa04dd4883d496f59eb1d82": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c11a0b4153bb41229b54f2c316e49fb6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6c3a98e141ef41ebac5033241e901a0a", + "placeholder": "​", + "style": "IPY_MODEL_176b8cafeae846b08bd905108c49c187", + "value": " 3/3 [00:00<00:00, 22.58it/s]" + } + }, + "c171ca6ce6c342e3a2b554f0a1e96946": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6469faa7ce30401c8406ace5479d0744", + "placeholder": "​", + "style": "IPY_MODEL_55ebce6aedaf44569ebe813c11d86db0", + "value": " 3/3 [00:00<00:00, 22.69it/s]" + } + }, + "c24c9d09c1ff4c4497c11e087cb74601": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5c2bdf30acb64fde97964052bf1158ea", + "placeholder": "​", + "style": "IPY_MODEL_c42e9afe917b4d238b64c8dae423a08c", + "value": "Validation DataLoader 0: 100%" + } + }, + "c33091d26af94d4f849426d89604efc6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c3ae2ada559f4a77834b47afeb954e2e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c42e9afe917b4d238b64c8dae423a08c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c47cbc67f63d4664a525f45cb9be802f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "c65cc31b212940c09f11ceb11c222ef4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c67eb73d43c449f2801750558f4a521d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c732b4b99e5e43de98eba24ea9330b8c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a2a5801a03eb4c488bea54a303de8aa8", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f58e5e4225644425a58df21cc258b2e9", + "value": 1 + } + }, + "c740afa60993457d959de43a861e200d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_84deef98024b48efb3f18fae1ee3dffc", + "placeholder": "​", + "style": "IPY_MODEL_a1b8f183134e41c3969882b651876c05", + "value": " 3/3 [00:00<00:00, 18.03it/s]" + } + }, + "c76e8e95ff844324b72e1ae2a040b673": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c88525bd6bf54f718d16f5e7b2c8a438": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_043020ee46b04b0e849aa065eb1688e6", + "IPY_MODEL_51a977e26e3246c0bb2f6e079a06a7bc", + "IPY_MODEL_d4614ca1e2ee41e3a78be809c911e5a7" + ], + "layout": "IPY_MODEL_56399d46ad8b44ed8ed0adf329893522" + } + }, + "c8f695256a574888af49e942ff0d53ea": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c91100e69a0e4320a37a979b0586d808": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c9899780726f453b8ef79792b92576cc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_efa1c19e95504fbfb3130ce5d2f9e06e", + "placeholder": "​", + "style": "IPY_MODEL_74f2bc8b9aee4fc9986ed0e6d833bab3", + "value": " 3/3 [00:00<00:00, 23.76it/s]" + } + }, + "cb153aa133b14ab08dfa44caeeb6b81e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cb3e60255a18440b8bd26c6682520e63": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cc1285bdc1a74576929e696b39cdff32": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_54afe3c681fd4869b5cc34d9aa410881", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_31a5f2acf0774510a8f94b1dd0c3611f", + "value": 1 + } + }, + "cc5789103b634ea091fe10e89a0fa387": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cd2246e275ab4283aea5036a3c083cc3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5d738cc2fe5447cb89f343a31554e050", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_daaac23228ea45da98b5c3819047daf2", + "value": 1 + } + }, + "cd7c7e091fc24d328e550c0c49fc3a8a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "cdeb0f7de79e4f06b4c76d92d276cb20": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ce568ae8b1bd4bc28cea074e0a295ef0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cf72bf7126a24a8281cfc4ff0dac558b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cf90653728a544029afdf0d285db1b71": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cfc3eed1a714480ea5c25697e9cfb760": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3083d2e358de4e00a24910dbff9d83d0", + "IPY_MODEL_ed779a27748c4413b93ddae88e3b6847", + "IPY_MODEL_4fd7a055897d495da333b612468f50d3" + ], + "layout": "IPY_MODEL_ff128da02ac640b8815356d193efb837" + } + }, + "cfddec8a651f495397214b49f9b8091d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d00f6502d78f48a6afd47fef76056b0c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8cba9c6709e5454ea15349dc42cfe0cd", + "placeholder": "​", + "style": "IPY_MODEL_f9b7ccdfa2be41a7a8f7a7a64699b47a", + "value": " 3/3 [00:00<00:00, 23.70it/s]" + } + }, + "d0e3de0c45944a3ca22baafdb51612b6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ec0d2f874c0b4d90b70dab8a364a7177", + "placeholder": "​", + "style": "IPY_MODEL_0aed735a0bef4bca94cc0f83fc6bb741", + "value": " 3/3 [00:00<00:00, 22.95it/s]" + } + }, + "d0fe8f14840146df9fc769f2ffc6f103": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d169d623177b4f73a73034c7f0b50b5d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d2232ad66e614f79aa31dacb583eac7e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d2b1934184984f6da6e2a9f0cc091e2e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f0c011f3be21460f8b128ff280d68808", + "IPY_MODEL_712feb908f5045e39b75f7123bb7dbf6", + "IPY_MODEL_a1478fa6b5ce4aa9bd0ccee4c50602f5" + ], + "layout": "IPY_MODEL_7a37a6630f874ef1af76b2c89f6fe269" + } + }, + "d43d30e849b048c5b038c0ea28051a29": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "d4614ca1e2ee41e3a78be809c911e5a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e8f6d51de5214b58938e06faacf9e90f", + "placeholder": "​", + "style": "IPY_MODEL_c76e8e95ff844324b72e1ae2a040b673", + "value": " 3/3 [00:00<00:00, 23.03it/s]" + } + }, + "d4ca8a1f229148a880d420776312aff2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d5cfe8ba6de44341a3a93ad3a4453def": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_021e47894cca42c88d89421b56dfb919", + "placeholder": "​", + "style": "IPY_MODEL_3cc8a7fba51942de9e82264e548c62a5", + "value": " 3/3 [00:00<00:00, 23.53it/s]" + } + }, + "d5ef045581f049caa9d79f10907e526a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6942c1a729a14fb7823c10209797414f", + "placeholder": "​", + "style": "IPY_MODEL_0d91c6de914d46af8891967ed2d6775a", + "value": " 3/3 [00:00<00:00, 23.22it/s]" + } + }, + "d61e750471554974ae9b07a81dce6932": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d63a1a9bacb04337b03301301ceed042": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7ef0a9a688f447a98ef9341b72b1a6ba", + "placeholder": "​", + "style": "IPY_MODEL_5671f7eaab934f108a1202ab876c0da9", + "value": "Validation DataLoader 0: 100%" + } + }, + "d794297461194c3d98cbf0f27d30b67a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d83d719827dc4cf18fd6b4be1a013b48": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "d8dea74096e64878b237c0a851aac991": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d911964788894e79855e0ae47953103a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_66a4a0681ee44eff8f045b7a385cd1a2", + "placeholder": "​", + "style": "IPY_MODEL_6a5a24e536314b55952f3ee2d8719970", + "value": "Validation DataLoader 0: 100%" + } + }, + "d93a2657edec4e23a50f067465192ee6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "da1ce1311a7a49a9b83bd4b6edeb6f98": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "da6176592b274c47aaeecc2428c76c9c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_273f928c594e471290863f82079d9180", + "IPY_MODEL_43ce5cc7a3794a9faed7a053c984636e", + "IPY_MODEL_c171ca6ce6c342e3a2b554f0a1e96946" + ], + "layout": "IPY_MODEL_df60c4135a444a448b0d200ecdd01e43" + } + }, + "daaac23228ea45da98b5c3819047daf2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "db212b22656948d9a190fc4a1a22d139": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_94b0542bd9a24f47829d80d75e9e6caf", + "placeholder": "​", + "style": "IPY_MODEL_3ee03c10f050486a953717e911d126c8", + "value": " 3/3 [00:00<00:00, 21.91it/s]" + } + }, + "db7f36c1229c472bbfca23cfc260f4c5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dbb3626925144fbb9366336171f85a41": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dce8d86194e345cc9fe8792d1bd457e8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3eff3edded23414db81879b4c2f6f5b8", + "IPY_MODEL_3c8c8708d15d43af8d9a86b752f019c9", + "IPY_MODEL_d00f6502d78f48a6afd47fef76056b0c" + ], + "layout": "IPY_MODEL_ab2dcf296209485aa2bdcc204e782715" + } + }, + "dd7333bf31cb4da9b0cbe872d706569b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "df60c4135a444a448b0d200ecdd01e43": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "e0b7aafcb493493eb7cc38dcc2e7e790": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "e2362e5efae7467b8e58786955739072": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e2a9cc1c6dea443ca1aa1841fa3fce5a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "e2f90203e06442c88ac36903ea85f8e7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_962668142d9b497db0704cbc10129a80", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3c85353efe9b47888787857596cb1741", + "value": 1 + } + }, + "e3308390869847b1a8c4123b5350f9d7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e34bdd70106343a5b8612b488b0113f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e4e08a2301f6407eb5cc13c15102efe6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2ee030af4e5541489a20050aad8efce5", + "placeholder": "​", + "style": "IPY_MODEL_d169d623177b4f73a73034c7f0b50b5d", + "value": " 3/3 [00:00<00:00, 22.39it/s]" + } + }, + "e4fa28df40184fef85979ecf49eb0227": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_29dad287ff434262917e99d4abe87e22", + "placeholder": "​", + "style": "IPY_MODEL_b068791a98704c6e8ab258319dad8263", + "value": "Validation DataLoader 0: 100%" + } + }, + "e51e2fae2577476eb17a5589654e4146": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e56dddf291fc4a87a8abcf35deb3ada4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a66f018d98b043a69b1877d53170c040", + "placeholder": "​", + "style": "IPY_MODEL_22d5c7797b224ceeab780e907164a7f8", + "value": " 3/3 [00:00<00:00, 23.31it/s]" + } + }, + "e6cf9c9bda7b4d37a0ea40d0565bdc25": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d4ca8a1f229148a880d420776312aff2", + "placeholder": "​", + "style": "IPY_MODEL_7eaa8bd25f384c9a8ba7fb6faed6b3f7", + "value": "Validation DataLoader 0: 100%" + } + }, + "e77db813dca54e869bea4a928040769a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b65b184f71e5418299c8c15f2982e874", + "placeholder": "​", + "style": "IPY_MODEL_49e5341ae44b43bc887609a461efc80b", + "value": " 3/3 [00:00<00:00, 22.78it/s]" + } + }, + "e80004eab2b54b4eafcfab7c2dec94d9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1f272fa725454bb3bf529bdf2604eb12", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_279a78ac51154592a3d288be64dc843f", + "value": 1 + } + }, + "e813e4725c4a43adba6363b551246f61": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e8d243e979184d43b46d66e8eaeec7fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e8eead01a58840588b916d34bac88da9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_890891d40cbd42c19ac36100fd39b3c4", + "IPY_MODEL_4ba6608f281b443094cd1a057fc56edf", + "IPY_MODEL_e56dddf291fc4a87a8abcf35deb3ada4" + ], + "layout": "IPY_MODEL_3593ff33dc6a422691e37ae61708a66b" + } + }, + "e8f6d51de5214b58938e06faacf9e90f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e9add7d8e3534205a85161a1dd8c0561": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_22da81f202af4f88849537be607e9ee3", + "placeholder": "​", + "style": "IPY_MODEL_eac934f0739245f6ab3366ce113ca5ea", + "value": "Validation DataLoader 0: 100%" + } + }, + "ea77318badcd47a48dc6631fc4b34705": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_bc896c2b5a674b58a8f4297c86335e6c", + "IPY_MODEL_524439135fb54e3ba86f5ace4eb06338", + "IPY_MODEL_8e6a75869f2f4ac5a531530b43b40718" + ], + "layout": "IPY_MODEL_5e923969e34848c6851b2b03c7b41841" + } + }, + "eabdb0f39f1f43cf8f5e37b2abfc279f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "eac934f0739245f6ab3366ce113ca5ea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "eadafdb5fc3d4f3b84df9ae41c5854aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "eb045b2ed03c4f31b6e30f8c54f5e34a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4e0c287d06814086b4c1b478fb11dfe5", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_451d8508824949d0ae06c2be42504f7b", + "value": 1 + } + }, + "eb974dbc33d040f9b178b3a77dd40596": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ebbf3193c2ea4b7d98d8504af04bb7e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d61e750471554974ae9b07a81dce6932", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7d6da8d8ded148e7958e1b747424828a", + "value": 1 + } + }, + "ebd8e5f5fc36423e854f3eb3d01a3ccb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4526a155d76542528b553180e2c9f107", + "IPY_MODEL_43ad8d40f2104267a64d02c8a4735f42", + "IPY_MODEL_f0d35a683ffe4f61a9ed609a837b0cc7" + ], + "layout": "IPY_MODEL_201b24c9f69c4af18145260bb4ecb762" + } + }, + "ec0d2f874c0b4d90b70dab8a364a7177": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ec1864db512149518a1b0cbbbab057d6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eccaed078ac547328383e1fb8c8422bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ece37dfc7f7846089b7ae9f620da5590": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ed779a27748c4413b93ddae88e3b6847": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_091cf2b9b40b414e9463f51088f93be9", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_bd24262a245b4a8fa786bc8a172e64d0", + "value": 1 + } + }, + "eecb9deb211c43c7b99d28a147d64574": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a52384c27ba84d7ea578c9b8973931f7", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2a928efa36a84ee6b7ddd50505f8bed9", + "value": 1 + } + }, + "efa1c19e95504fbfb3130ce5d2f9e06e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "efa4351f438740ebb3b555206fe96b6e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "f0607bf5f1644ca2950b93029d08cdef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f0c011f3be21460f8b128ff280d68808": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5f8819ebd06e4a3f8dab4a84855019dd", + "placeholder": "​", + "style": "IPY_MODEL_103b137bb36a47fcbbbe9b0c3f2e2a20", + "value": "Validation DataLoader 0: 100%" + } + }, + "f0d35a683ffe4f61a9ed609a837b0cc7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e3308390869847b1a8c4123b5350f9d7", + "placeholder": "​", + "style": "IPY_MODEL_17bdd1be5491412cacbecb7feeae2fc7", + "value": " 3/3 [00:00<00:00, 23.20it/s]" + } + }, + "f110be5d117b49ffb8f696ebeb44fd54": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f12bed710be1411f8e30968f4e09554e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e6cf9c9bda7b4d37a0ea40d0565bdc25", + "IPY_MODEL_7cb62ceb722f4d38b9c5d80b32b0841a", + "IPY_MODEL_9c0cb0386434437681770e99b0db0744" + ], + "layout": "IPY_MODEL_413006fb9d2e453abf39cdd4b91caa75" + } + }, + "f148afd0ea3a4625a3600fc67c3693ff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f3ab972f1ab14fd69d87e7a9af800aaf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "f3c46fae7ba04122b9ea6721d3fd59f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b1eabe6afaab4879b4e60b75a13c53f2", + "placeholder": "​", + "style": "IPY_MODEL_561adb0dc1c943e6ac7734d9d214f35a", + "value": " 3/3 [00:00<00:00, 23.18it/s]" + } + }, + "f45de29667c64d98a6d84e5fc642c631": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_88123fd47960496e989711120607b605", + "placeholder": "​", + "style": "IPY_MODEL_f0607bf5f1644ca2950b93029d08cdef", + "value": "Validation DataLoader 0: 100%" + } + }, + "f58e5e4225644425a58df21cc258b2e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f5bdab9255224de7ae62b4c83169c022": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8f76fcea6a0a45d1af4d5e4985ababda", + "placeholder": "​", + "style": "IPY_MODEL_fea61d5d08c349faae33df0f4b6cbbb9", + "value": " 3/3 [00:00<00:00, 20.76it/s]" + } + }, + "f62028910b1a4e299444705e7795058c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5d11defaa1624b83a8a47e4745a13d7a", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_5d57d4c3e3a24cac8a8ab228b199ca22", + "value": 1 + } + }, + "f65b58b468a442fa9eeef48cccb9164f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cb3e60255a18440b8bd26c6682520e63", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0b1024f20aaa459aabd611e80ae46e53", + "value": 1 + } + }, + "f73f08cd498a47eaa01b6ee3e0a9d288": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f88883a2b4ba433692a7d91e76cb64c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_170c77c2f53347eba458933ccc9fade6", + "IPY_MODEL_b673982fde464818902b9d9188682521", + "IPY_MODEL_631e42e29fa24b01bdf65a52c5a3789e" + ], + "layout": "IPY_MODEL_c47cbc67f63d4664a525f45cb9be802f" + } + }, + "f909105afa944e23a3bd7448050b8e24": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_07b7b5dcb848469e8f53eeedf1bc6b33", + "placeholder": "​", + "style": "IPY_MODEL_3a923915a02341c8adda26e702a58649", + "value": " 3/3 [00:00<00:00, 23.53it/s]" + } + }, + "f977f92cd00040b79d1370265c355470": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d794297461194c3d98cbf0f27d30b67a", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_27807cb739b249a59a6e0d9d317414df", + "value": 1 + } + }, + "f9b7ccdfa2be41a7a8f7a7a64699b47a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fa210271474f4e82bb4d087e1ffeee4f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fa8df0bc1a3d4b469ee5f3d25a0f92d2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2fa9970eb2344e038499dc2a08791f13", + "placeholder": "​", + "style": "IPY_MODEL_48333bff75384cf7886c81ca1e3f0056", + "value": " 3/3 [00:00<00:00, 18.40it/s]" + } + }, + "faa2148c3d1849708c7c61edd90e1291": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fb12c181ee7d42c7aa4256347200bea4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c67eb73d43c449f2801750558f4a521d", + "placeholder": "​", + "style": "IPY_MODEL_c0c48b257aa04dd4883d496f59eb1d82", + "value": "Validation DataLoader 0: 100%" + } + }, + "fc0b3426a46844028503ab46da1230fe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fdd0ef85a11e431c8b9584622aa675f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3389a58f19334452a8a25dbe5e19f09a", + "placeholder": "​", + "style": "IPY_MODEL_afbf370d7070420baad9e7ce8b643456", + "value": "Validation DataLoader 0: 100%" + } + }, + "fe23ff3e550a48de82471507e913f733": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "fe72db6203cc472695e2217021d84b33": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_966280e648174531853430b876c96b3e", + "placeholder": "​", + "style": "IPY_MODEL_80b7e2aa713a45ca9c2bf8eae7d6bb4d", + "value": "Validation DataLoader 0: 100%" + } + }, + "fea61d5d08c349faae33df0f4b6cbbb9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ff128da02ac640b8815356d193efb837": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "ff75dc1b2fbd42dd804840d7a2e6a5e3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ffae1f6825c045178ae33dea1d805c87": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fb12c181ee7d42c7aa4256347200bea4", + "IPY_MODEL_bc93eb10d7f44b559d17c6b5c6cb93b7", + "IPY_MODEL_209c4f3f80e14a969afb2b32c7216dbd" + ], + "layout": "IPY_MODEL_2345ab7c9cfb4dc295f34c54579408fb" + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorials/dna-imaging/Notebooks/Simulation_of_DNA_chain_with_U_Net.ipynb b/tutorials/dna-imaging/Notebooks/Simulation_of_DNA_chain_with_U_Net.ipynb deleted file mode 100644 index 6558248..0000000 --- a/tutorials/dna-imaging/Notebooks/Simulation_of_DNA_chain_with_U_Net.ipynb +++ /dev/null @@ -1,25877 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "cell_md_title", - "metadata": { - "id": "cell_md_title" - }, - "source": [ - "# Simulation of 'DNA chains on a substrate imaged via AFM'\n", - "**This notebook is intended to create simulations of DNA chain relaxation on a substrate imaged via AFM. By simulating physical relaxation and electrostatic attraction between a DNA chain and the substrate it allows users to generate high fidelity data.**\n", - "\n", - "This notebook generates a complete dataset stored within user defined directory `OUT_DIR`, primarily consisting of Synthetic AFM Images saved as `.npy` raw heightmap data (incorporating realistic noise from `.spm` blanks or PSD models) and optional `.png` files for quick visual inspection.\n", - "\n", - " To support machine learning workflows, the pipeline produces DNA Segmentation Masks in `.npy` format for pixel-wise background separation, alongside specialized Crossing Detection Masks that use Gaussian-weighted targets to highlight molecular intersections. Comprehensive Metadata for every sample, including bead counts and mechanical parameters, is saved in `.csv` or `.json` files, all of which are indexed in a central **manifest.csv** that links each generated image to its corresponding ground-truth masks and input configurations.\n", - ">\n", - "---\n", - "**Cell execution order:** run cells 1 → 12 in sequence. \n", - "Cells 1–9 define functions and globals. Cell 10 is the sanity check. Cell 11 is used for benchmarking the time for execution and generation of the dataset. Cell 12 generates the full dataset.\n", - "\n", - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github.com/Prakhar-Dutta/ASAP/blob/1b5cfc5173e1bed4e59575e6dd4724cb20682620/tutorial/Not_final_version_DNA_notebook%20(1).ipynb)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "glVt-o8bCqSu", - "metadata": { - "id": "glVt-o8bCqSu" - }, - "outputs": [], - "source": [ - "from __future__ import annotations\n", - "\n", - "# Uncomment codes in this cell if using Colab/Kaggle.\n", - "import os\n", - "from pathlib import Path\n", - "import re\n", - "import csv\n", - "import traceback\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib import animation\n", - "from IPython.display import HTML, display\n", - "from typing import Any\n", - "# Image processing\n", - "from scipy.ndimage import (\n", - " gaussian_filter, grey_dilation, distance_transform_edt,\n", - " binary_dilation, median_filter, affine_transform, zoom\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "2nb1FTtFC_q0", - "metadata": { - "id": "2nb1FTtFC_q0" - }, - "source": [ - "# 1. **With or without molecular dynamics?**\n", - "## 1.1. Imports\n", - "\n", - "This notebook allows two possible ways of building the simulated DNA chains; with or without the use of **coarse-grained molecular dynamics**. Molecular dynamics based simulations are computationally expensive, but provide closeness to real AFM imaging. For users who would like to use molecular dynamics, they would need to import all the libraries that will be necessary for simulation of the images." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "cell_code_01", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "cell_code_01", - "outputId": "c24440c9-88c5-4f0e-ffea-2637536132b4" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Requirement already satisfied: openmm[cuda12] in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (8.5.0)\n", - "Requirement already satisfied: numpy in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from openmm[cuda12]) (2.2.6)\n", - "Requirement already satisfied: OpenMM-CUDA-12==8.5.0 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from openmm[cuda12]) (8.5.0)\n", - "Requirement already satisfied: nvidia-cuda-runtime-cu12 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from OpenMM-CUDA-12==8.5.0->openmm[cuda12]) (12.9.79)\n", - "Requirement already satisfied: nvidia-cuda-nvcc-cu12 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from OpenMM-CUDA-12==8.5.0->openmm[cuda12]) (12.9.86)\n", - "Requirement already satisfied: nvidia-cuda-nvrtc-cu12 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from OpenMM-CUDA-12==8.5.0->openmm[cuda12]) (12.9.86)\n", - "Requirement already satisfied: nvidia-cuda-cupti-cu12 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from OpenMM-CUDA-12==8.5.0->openmm[cuda12]) (12.9.79)\n", - "Requirement already satisfied: nvidia-cufft-cu12 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from OpenMM-CUDA-12==8.5.0->openmm[cuda12]) (11.4.1.4)\n", - "Requirement already satisfied: nvidia-nvjitlink-cu12 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from nvidia-cufft-cu12->OpenMM-CUDA-12==8.5.0->openmm[cuda12]) (12.9.86)\n" - ] - } - ], - "source": [ - "# Install dependencies (uncomment in a fresh environment / Colab)\n", - "# Chain generation mode\n", - "USE_MD = True # True → OpenMM Langevin dynamics\n", - " # False → fast 2-D persistent-walk (no OpenMM needed)\n", - "# Molecular dynamics\n", - "!pip3 install -q scipy matplotlib pillow\n", - "if USE_MD:\n", - " !pip3 install openmm[cuda12]\n", - "# change the cuda version\n", - "# depending on the CUDA version available on your system.\n", - "# Ensure that CUDA can be accessed by OpenMM when running locally.\n", - " import openmm\n", - " import openmm.unit as unit\n" - ] - }, - { - "cell_type": "markdown", - "id": "1oW9llw-imr1", - "metadata": { - "id": "1oW9llw-imr1" - }, - "source": [ - "# 1.2 Defining the variables\n", - "Here we define the variables that will be used for the generation of the images and the masks. The variables control how the images and their masks will appear at the end. For training a Machine learning network like a U-Net, all images need to be of a standard size and need reproducible properties. To generate the likeness of DNA chains from simulated data, we start with building a chain by using a random walk in 3D with some set parameters like number of beads, bond length and persistence bonds and to simulate chain relaxation on substrate we raise the chain to a certain height." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "sSqadS02hzPe", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "sSqadS02hzPe", - "outputId": "1c71be52-13a0-44bf-fa0d-6fde02a62dad" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Output folder: c:\\Users\\xdutpr\\OneDrive - Chalmers\\AFM_pipeline\\dna-afm.venv\\Scripts\\dna_dataset_100_4lengths_MD\n" - ] - } - ], - "source": [ - "# ─────────────────────────────────────────────────────────────────────────────\n", - "# Global settings\n", - "#(these are the variables that need to be changed\n", - "# to change the appearance of the resulting images)\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "\n", - "# Dataset\n", - "OUT_DIR = \"dna_dataset_100_4lengths_MD\"\n", - "# Name of the output directory that you would like to store your data in\n", - "N_SAMPLES = 100\n", - "# Number of samples that will be generated\n", - "BASE_SEED = 1\n", - "# Seed for reproducibility\n", - "\n", - "# Image resolution\n", - "NX = 512\n", - "NY = 512\n", - "\n", - "# Ring + MD\n", - "N_BEADS = 90\n", - "# default bead count for vizualization via chain creation cell\n", - "BEAD_COUNTS = [70, 80, 90, 100]\n", - "# four chain lengths that will be created in the dataset\n", - "#(1 bead corresponds to 1nm which is roughly 4 base pairs)\n", - "BOND_LENGTH = 1.0\n", - "# distance between beads\n", - "PERSISTENCE_BONDS = 23.0\n", - "# used to determine the range of angles which the chain is allowed to turn\n", - "K_ANGLE = 12.0\n", - "# used to determine the angular stiffness during relaxation\n", - "# (higher means more stiffness)\n", - "BASE_Z = 5.0\n", - "# Height above the substrate that the chain starts at before relaxing\n", - "\n", - "ANGLE_STIFNESS_MULT = 0.4\n", - "# If USE_MD is False, then angle stiffness multiplier controls\n", - "# chain propogation through space\n", - "\n", - "# MD recording\n", - "N_FRAMES = 200\n", - "STEPS_PER_FRAME = 200\n", - "# Between every frame local energy minimization happens for\n", - "#the given number of steps\n", - "\n", - "# AFM rendering\n", - "\n", - "tip_radius = 1\n", - "# Please select the tip radius here (Ideal range is 1nm-5nm)\n", - "nm_per_px = 2\n", - "# Internal AFM render sampling in nm / pixel before downsampling\n", - "\n", - "AFM_KW = dict(\n", - " nx=NX, ny=NY,\n", - " dna_diameter_nm=2.0,\n", - " # mapping to physical values\n", - " tip_radius_nm=0.01*tip_radius,\n", - " # Scaling factor is applied for internal control to match\n", - " max_height_nm=6.0,\n", - " # Maximum height for the colorbar\n", - " target_nm_per_px=0.04*nm_per_px,\n", - " # Scaling factor (0.04) is applied for internal control\n", - " max_radius_px=96,\n", - " # upper limit for the size of the chain in pixels\n", - " radius_shrink_px=0.0,\n", - " # Set to 0 so that rendering can match physical values\n", - " final_blur_sigma_px=0.20,\n", - " # When changing tip radius and nm_per_px to observe the expected\n", - " apply_edge_taper=True,\n", - " # physical effect, remove the scaling factors (0.04) for\n", - " # tip_radius_nm and target_nm_per_px\n", - " taper_sigma_nm=0.45,\n", - " # and scale all other parameters accordingly.\n", - " taper_floor=0.10,\n", - " add_center_ridge=True,\n", - " ridge_sigma_nm=0.25,\n", - " # This controls width of center ridge\n", - " ridge_amp_nm=0.25,\n", - " # This controls height of center ridge\n", - " grain_nm=0.0,\n", - " # This adds more noise to the chain\n", - " grain_sigma_px=0.6,\n", - " enable_crossing_boost=True,\n", - " # To boost the height of the crossings\n", - " min_separation_beads=12,\n", - " # Distance to other chain segments to not boost indiscriminately\n", - " boost_window_beads=2,\n", - " # How many beads to boost the height for\n", - " guaranteed_offset_nm=1.0,\n", - " # How much to boost\n", - " boost_method=\"additive\",\n", - " # add to the height of beads being boosted\n", - " boost_profile=\"gaussian\",\n", - " # Height increase profile\n", - " boost_sigma_beads=None,\n", - " far_clip_nm=2.5,\n", - " # Clip bead heights for beads that are not part of a crossing\n", - " far_clip_window_beads=3,\n", - " # How many beads to clip the height for\n", - " return_crossing_info=True,\n", - " # To ensure that mask information is passed to other functions.\n", - " # Change to False if masks are not needed\n", - " return_masks=True,\n", - ")\n", - "\n", - "\n", - "#-------------------------------------\n", - "# DNA mask\n", - "DNA_MASK_DILATE_PX = 3\n", - "# Dilation of mask for better training\n", - "#-------------------------------------\n", - "\n", - "#---------------------------\n", - "# Crossing mask\n", - "CROSS_MIN_SEP_BEADS = 10\n", - "# Where to stop for the crossing calculation\n", - "CROSS_SIGMA_CENTER_PX = 4.0\n", - "# How many pixels make up the center of a crossing\n", - "CROSS_SIGMA_PERP_PX = 1.8\n", - "# Crossing coloring parameter (how many pixels to modulate for the crossing)\n", - "CROSS_CHAIN_EXTENT = 4.0\n", - "# For the chain weighting of the mask\n", - "CROSS_CENTER_WEIGHT = 1.5\n", - "# For the chain weighting of the mask (chain-weighted guassian)\n", - "CROSS_CHAIN_WEIGHT = 0.9\n", - "CROSS_CLIP_TO_DNA_MASK = True\n", - "#---------------------------\n", - "\n", - "#Checking if output directory will be created\n", - "os.makedirs(OUT_DIR, exist_ok=True)\n", - "for _sub in [\"images\", \"dna_masks\", \"cross_masks\", \"meta\"]:\n", - " os.makedirs(os.path.join(OUT_DIR, _sub), exist_ok=True)\n", - "\n", - "print(\"Output folder:\", os.path.abspath(OUT_DIR))" - ] - }, - { - "cell_type": "markdown", - "id": "-e3QvQzGlKYY", - "metadata": { - "id": "-e3QvQzGlKYY" - }, - "source": [ - "# 1.3 Noise\n", - "To add realistic noise to the images so that they closely resemble real AFM images, 2 options have been provided in this notebook.\n", - "\n", - "\n", - "1. For users that have access to AFM imaging setups and substrates, a **blank ``.spm``** file can be loaded into this enviroment. The blank file is a scan of the substrate **without** the sample of interest. The notebook will parse through the file and add the noise that would appear as if a DNA chain were imaged on that substrate, thus making the output dataset closer to real DNA if it were to be imaged on that setup and substrate.\n", - "2. For users that do not have access to AFM imaging setups or available blanks, noise can be generated through an ensemble of blanks that were imaged on nickel susbtrates and processed. The information of that noise is available as a Power spectral density noise model that is available in this repository. There are 3 noise synthesis models offered but *mean_full2d* is preferred and chosen as the default.\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "47h81smulGxd", - "metadata": { - "id": "47h81smulGxd" - }, - "outputs": [], - "source": [ - "#Noise\n", - "TARGET_NOISE_RMS_NM = 0.27\n", - "# This variable controls the height of the noise\n", - "# in nanometers and this is added to the final image\n", - "\n", - "\n", - "# Blank SPM noise\n", - "USE_BLANK_SPM_NOISE = True\n", - "USE_PLANE_REMOVE = True\n", - "# This flag is used to control plane tilt removal from the noise image\n", - "USE_LINE_FLATTEN = True\n", - "# This flag is used to control line flattening (median filtering)\n", - "# from the noise image\n", - "USE_BANDPASS_FILTER = True\n", - "# This flag is used to control bandpass filtering on the noise image\n", - "BLANK_SPM_PATH = \"20240411_blank_water.0_00000.spm\"\n", - "# optional; if missing/invalid, PSD fallback noise is used\n", - "# Change path when running locally. If using Colab, upload the file\n", - "\n", - "\n", - "# PSD-model fallback noise (used when blank .spm file is not available)\n", - "USE_PSD_NOISE_FALLBACK = True\n", - "MODEL_PATH = \"/content/psd_noise_model.npz\"\n", - "# Change path when running locally. If using Colab, upload the noise file\n", - "PSD_NOISE_METHOD = \"mean_full2d\"\n", - "# or \"lognormal_full2d\" / \"empirical_radial\"\n", - "PSD_NOISE_STD_SCALE = 2.0\n" - ] - }, - { - "cell_type": "markdown", - "id": "cell_md_02", - "metadata": { - "id": "cell_md_02" - }, - "source": [ - "## 2. Chain Creation (3-D Persistent Random Walk)\n", - "Now we start with creating the DNA chain. This is the toppology of the chain before relaxation is performed using molecular dynamnics.\n", - "\n", - "The function `make_tangled_ring_initial` builds a closed polymer ring via a persistent random walk and enforces ring-closure.\n", - "\n", - "A 3-D plot is shown at the end of the cell so you can inspect the initial geometry immediately." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "cell_code_02", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 607 - }, - "id": "cell_code_02", - "outputId": "1271afac-e3a9-4d53-8120-a9428866a15c" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def make_tangled_ring_initial(\n", - " seed: int,\n", - " n_beads: int = N_BEADS,\n", - " bond_length: float = BOND_LENGTH,\n", - " persistence_bonds: float = PERSISTENCE_BONDS,\n", - " base_z: float = BASE_Z,\n", - ")-> np.ndarray:\n", - " \"\"\"Generates a closed (ring) polymer with a persistent random-walk tangent.\n", - "\n", - " Each step rotates the current direction by a small random angle around a\n", - " perpendicular axis. Ring closure is enforced by linearly distributing\n", - " the end-to-end gap across all beads. The chain is then lifted to base_z\n", - " so it can relax down to the z=0 substrate during MD.\n", - "\n", - " Parameters\n", - " ----------\n", - " seed : int\n", - " random seed for reproducibility\n", - " n_beads : int, optional\n", - " number of beads in the polymer ring. Defaults to N_BEADS.\n", - " bond_length : float, optional\n", - " the distance between consecutive beads. Defaults to BOND_LENGTH.\n", - " persistence_bonds : float, optional\n", - " the number of beads used to enforce persistence length in the chain.\n", - " Defaults to PERSISTENCE_BONDS.\n", - " base_z : float\n", - " the height to lift the chain above the substrate. Defaults to BASE_Z.\n", - "\n", - " Returns\n", - " -------\n", - " Returns a list of [coords] with shape (N, 3).\n", - "\n", - " \"\"\"\n", - "\n", - " rng = np.random.default_rng(int(seed))\n", - "\n", - " steps = np.zeros((n_beads, 3), dtype=np.float32)\n", - " #Initialization of vector for chain propogation\n", - " vec = np.array([1.0, 0.0, 0.0], dtype=np.float32)\n", - "\n", - " for k in range(n_beads):\n", - " dtheta = rng.normal(scale=np.sqrt(1.0 / persistence_bonds))\n", - " #choose an axis at random for chain propogation in 3D\n", - " axis = rng.normal(size=3).astype(np.float32)\n", - " # remove component along vec\n", - " axis -= axis.dot(vec) * vec\n", - " axis_norm = np.linalg.norm(axis)\n", - " # failsafe\n", - " if axis_norm < 1e-8:\n", - " axis = np.array([0.0, 0.0, 1.0], dtype=np.float32)\n", - " axis_norm = 1.0\n", - " axis /= axis_norm\n", - " # Calculating vector for chain propogation\n", - " vec = vec * np.cos(dtheta) + np.cross(axis, vec) * np.sin(dtheta)\n", - " vec /= np.linalg.norm(vec)\n", - " steps[k] = bond_length * vec\n", - "\n", - " coords = np.cumsum(steps, axis=0) # Coordinates for open chain\n", - "\n", - " # Enforce ring closure\n", - " closure_error = coords[-1] - coords[0]\n", - " # Based on the distance between first and last bead a\n", - " # closure error is propogated to all bead positions to form a closed chain\n", - " t = np.linspace(0, 1, n_beads, dtype=np.float32).reshape(-1, 1)\n", - " coords -= t * closure_error\n", - " coords -= coords.mean(axis=0)\n", - "\n", - " # Lift above substrate\n", - " # (z values are changed to lift the chain off the substrate)\n", - " coords[:, 2] += float(base_z)\n", - " return coords.astype(np.float32)\n", - "\n", - "\n", - "# ── Quick visualisation ──────────────────────────────────────────────────────\n", - "demo_coords = make_tangled_ring_initial(seed=43)\n", - "cc = np.vstack([demo_coords, demo_coords[0]]) # close the ring for plotting\n", - "\n", - "fig = plt.figure(figsize=(7, 6))\n", - "ax = fig.add_subplot(111, projection=\"3d\")\n", - "ax.plot(cc[:, 0], cc[:, 1], cc[:, 2], \"-o\", markersize=3, linewidth=1.2)\n", - "ax.scatter(cc[0, 0], cc[0, 1], cc[0, 2], color=\"red\",\n", - " s=60, zorder=5, label=\"bead 0\")\n", - "\n", - "# Draw substrate plane\n", - "xs = np.linspace(cc[:, 0].min(), cc[:, 0].max(), 2)\n", - "ys = np.linspace(cc[:, 1].min(), cc[:, 1].max(), 2)\n", - "X, Y = np.meshgrid(xs, ys)\n", - "ax.plot_surface(X, Y, np.zeros_like(X), alpha=0.15, color=\"cyan\")\n", - "\n", - "ax.set_xlabel(\"x (sim units)\"); ax.set_ylabel(\"y\"); ax.set_zlabel(\"z\")\n", - "ax.set_title(f\"Initial ring — seed 43, {len(demo_coords)} beads\")\n", - "ax.legend()\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "cell_md_03", - "metadata": { - "id": "cell_md_03" - }, - "source": [ - "## 3. Molecular Dynamics Relaxation\n", - "To accurately mimic chain relaxation on a susbstrate a coarse grained molecular dynamics simulation is performed using OpenMM (no water or other molecules simulated). If Molecular dynamics is not needed, please skip this cell.\n", - "\n", - "The function `run_md_relaxation` runs a Langevin-dynamics simulation in the overdampled regime via OpenMM.\n", - "Here we have added:\n", - "\n", - "1. Harmonic bonds\n", - "2. Bending-angle stiffness\n", - "3. A surface-attraction to cause chain relaxation\n", - "4. A hard-wall force to keep chain above substrate\n", - "5. A short-range WCA repulsion to ensure chain does not take non physical configurations\n", - "\n", - "The function then records `n_frames` snapshots which can be used for visualization." - ] - }, - { - "cell_type": "markdown", - "id": "wFFhsVZhqU8a", - "metadata": { - "id": "wFFhsVZhqU8a" - }, - "source": [ - "We start with testing the OpenMM installation (can be tricky at times)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "3NjBSwfAe4Mj", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "3NjBSwfAe4Mj", - "outputId": "9ed84c26-7ee9-4552-dc85-cbed8551af08" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "OpenMM Version: 8.5\n", - "Git Revision: b55e60882dffcddb2532cceda4201c0fdc9ec2d5\n", - "\n", - "There are 3 Platforms available:\n", - "\n", - "1 Reference - Successfully computed forces\n", - "2 CPU - Successfully computed forces\n", - "3 OpenCL - Successfully computed forces\n", - "\n", - "Median difference in forces between platforms:\n", - "\n", - "Reference vs. CPU: 6.30121e-06\n", - "Reference vs. OpenCL: 6.74321e-06\n", - "CPU vs. OpenCL: 7.73523e-07\n", - "\n", - "All differences are within tolerance.\n" - ] - } - ], - "source": [ - "# Test the OpenMM installation before running the following cell\n", - "# to ensure that GPU acceleration will work\n", - "import openmm.testInstallation\n", - "\n", - "# Run the standard OpenMM installation test to check for CUDA/GPU support\n", - "try:\n", - " openmm.testInstallation.main()\n", - "except Exception as e:\n", - " print(f\"Test failed: {e}\")" - ] - }, - { - "cell_type": "markdown", - "id": "9XbRNS3TqbKH", - "metadata": { - "id": "9XbRNS3TqbKH" - }, - "source": [ - "And then once we are sure that OpenMM is correctly installed, we run the MD functions" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "id": "cell_code_03", - "metadata": { - "id": "cell_code_03" - }, - "outputs": [], - "source": [ - "def run_md_relaxation(\n", - " coords0: np.ndarray,\n", - " seed: int,\n", - " n_frames: int = N_FRAMES,\n", - " steps_per_frame: int = STEPS_PER_FRAME,\n", - ")-> list[np.ndarray]:\n", - " \"\"\"\n", - " Takes initial bead coordinates and runs Langevin dynamics using OpenMM\n", - "\n", - " This function uses the coordinates generated using the\n", - " `make_tangled_ring_initial` function to run a molecular dynamics\n", - " simulation. There are certain forces that are defined and applied to the\n", - " bead which are then resolved using OpenMM.\n", - " The forces applied are:\n", - " - Harmonic bonds + angle stiffness along the ring\n", - " - Surface attraction (linear in z) + hard wall at z = 0\n", - " - Short-range Weeks–Chandler–Andersen (WCA)\n", - " repulsion between non-bonded beads\n", - " Drift removal is also performed using OpenMM's CMMotionRemover.\n", - " The variable langevin integrator from OpenMM is used and the forces are\n", - " resolved for 'steps_per_frame' steps for every frame in n_frames.\n", - "\n", - " Parameters\n", - " ----------\n", - " initial_coordinates : np.ndarray\n", - " The starting [x, y, z] coordinates of the polymer beads.\n", - " seed : int\n", - " Random seed for the Langevin integrator.\n", - " num_frames : int, optional\n", - " Number of frames to record during the simulation. Defaults to N_FRAMES.\n", - " steps_per_frame : int, optional\n", - " Number of integration steps to perform between recorded frames.\n", - " Defaults to STEPS_PER_FRAME.\n", - "\n", - " Returns\n", - " -------\n", - " A list of coordinate arrays of shape (num_beads, 3). The list contains\n", - " num_frames + 1 entries, where frame 0 is the pre-minimization geometry.\n", - "\n", - " Raises\n", - " ------\n", - " RuntimeError\n", - " If no OpenMM platform (CUDA, OpenCL, or CPU) could be initialised.\n", - "\n", - " Examples\n", - " --------\n", - " >>> frames = run_md_relaxation(_anim_coords0, seed=1, n_frames=N_FRAMES,\n", - " steps_per_frame=STEPS_PER_FRAME)\n", - " >>> print({len(frames), frames[0].shape})\n", - " {11, (100, 3)}\n", - "\n", - " \"\"\"\n", - "\n", - " coords0 = np.asarray(coords0, dtype=np.float32)\n", - " n = int(coords0.shape[0])\n", - "\n", - " # how big the bounding box for the molecular dynamics needs to be\n", - " extent = (coords0.max(axis=0) - coords0.min(axis=0)).max()\n", - " box = float(extent + 10.0)\n", - "\n", - "\n", - " # All lengths in nm, energies in kJ/mol.\n", - " BOLTZ_kJmol = 0.00831445 # kJ / (mol · K)\n", - " temperature = 1.0 # K (sets energy scale kT ≈ 0.0083 kJ/mol)\n", - " kT = BOLTZ_kJmol * temperature # kJ/mol\n", - " conlen = 1.0 # nm\n", - " mass_amu = 100.0 # Da per bead\n", - " collision_rate = 0.6 # ps⁻¹\n", - " error_tol = 0.005\n", - "\n", - " # ── Build system ─────────────────────────────────────────────────────────\n", - " system = openmm.System()\n", - " system.setDefaultPeriodicBoxVectors(\n", - " openmm.Vec3(box, 0, 0),\n", - " openmm.Vec3(0, box, 0),\n", - " openmm.Vec3(0, 0, box),\n", - " )\n", - " for _ in range(n):\n", - " system.addParticle(mass_amu)\n", - "\n", - " # Remove COM drift — applied every 50 steps\n", - " system.addForce(openmm.CMMotionRemover(10))\n", - " # To ensure CPU and GPU calculation are consistent\n", - " # (since GPU minimizations calculations can suffer from drift)\n", - "\n", - " # ── 1. Harmonic bonds ────────────────────────────────────────────────────\n", - "\n", - " # OpenMM HarmonicBondForce: E = (k/2)·(r − r0)² → k = kT / wiggle²\n", - " bond_L = BOND_LENGTH # nm\n", - " wiggle = 0.1 # nm (bondWiggleDistance)\n", - " k_bond = kT / (wiggle ** 2) # kJ/mol/nm²\n", - "\n", - " bond_force = openmm.HarmonicBondForce()\n", - " bond_force.setUsesPeriodicBoundaryConditions(True)\n", - " for i in range(n):\n", - " bond_force.addBond(i, (i + 1) % n, bond_L, k_bond)\n", - " system.addForce(bond_force)\n", - "\n", - " # ── 2. Bending (angle) stiffness ─────────────────────────────────────────\n", - " # E = kT · k_angle · (1 − cos(θ − π)) — equilibrium at θ = π (straight)\n", - " k_angle = K_ANGLE\n", - " angle_force = openmm.CustomAngleForce(\n", - " \"kT * kangle * (1 - cos(theta - 3.141592653589793))\"\n", - " )\n", - " angle_force.addGlobalParameter(\"kT\", kT)\n", - " angle_force.addGlobalParameter(\"kangle\", k_angle)\n", - " for i in range(n):\n", - " angle_force.addAngle((i - 1) % n, i, (i + 1) % n, [])\n", - " system.addForce(angle_force)\n", - "\n", - " # ── 3. Surface: linear attraction (z > 0) + harmonic hard wall (z < 0) ───\n", - " wall_expr = (\n", - " \"kT * (\"\n", - " \" F_pull * z * step(z) + \"\n", - " \" 0.5 * wallK * (z^2) * step(-z)\"\n", - " \")\"\n", - " )\n", - " wall_force = openmm.CustomExternalForce(wall_expr)\n", - " wall_force.addGlobalParameter(\"kT\", kT)\n", - " wall_force.addGlobalParameter(\"F_pull\", 9.0)\n", - " wall_force.addGlobalParameter(\"wallK\", 100.0)\n", - " for i in range(n):\n", - " wall_force.addParticle(i, [])\n", - " system.addForce(wall_force)\n", - "\n", - " # ── 4. WCA repulsion (repulsion between non-bonded pairs only) ───────────\n", - " rep_sigma = 1.6 * conlen # nm\n", - " rep_cutoff = 2.3 * conlen # nm\n", - " rep_expr = (\n", - " \"4*eps * ( (sig / (r + shift))^12 - (sig / (r + shift))^6 + 0.25 )\"\n", - " \"* step(cutoff - r);\"\n", - " \"cutoff = 2^(1.0/6.0) * sig\"\n", - " )\n", - " rep_force = openmm.CustomNonbondedForce(rep_expr)\n", - " rep_force.setNonbondedMethod(openmm.CustomNonbondedForce.CutoffPeriodic)\n", - " rep_force.setCutoffDistance(rep_cutoff)\n", - " rep_force.addGlobalParameter(\"eps\", 1.7 * kT)\n", - " rep_force.addGlobalParameter(\"sig\", rep_sigma)\n", - " rep_force.addGlobalParameter(\"shift\", 1e-8)\n", - " for i in range(n):\n", - " rep_force.addParticle([])\n", - " # exclude bonded neighbours\n", - " for i in range(n):\n", - " rep_force.addExclusion(i, (i + 1) % n)\n", - " system.addForce(rep_force)\n", - "\n", - " # ── Integrator ───────────────────────────────────────────────────────────\n", - " integrator = openmm.VariableLangevinIntegrator(temperature,\n", - " collision_rate, error_tol)\n", - " integrator.setRandomNumberSeed(int(seed))\n", - "\n", - " # ── Platform selection: OpenCL → CPU fallback ────────────────────────────\n", - " context = None\n", - " # OpenCL enables Mac users to be able to use GPU acceleration as well\n", - " for platform_name in (\"CUDA\",\"OpenCL\",\"CPU\"):\n", - " try:\n", - " platform = openmm.Platform.getPlatformByName(platform_name)\n", - " context = openmm.Context(system, integrator, platform)\n", - " print(f\"Using {platform_name} platform.\")\n", - " break\n", - " except openmm.OpenMMException as e:\n", - " print(f\" {platform_name} unavailable: {e}\")\n", - " except Exception as e:\n", - " print(f\" {platform_name} failed unexpectedly: {e}\")\n", - "\n", - " if context is None:\n", - " raise RuntimeError(\"No OpenMM platform could be initialised.\")\n", - "\n", - " # ── Set initial positions and box ────────────────────────────────────────\n", - " positions = [\n", - " openmm.Vec3(float(coords0[i, 0]),\n", - " float(coords0[i, 1]), float(coords0[i, 2]))\n", - " for i in range(n)\n", - " ]\n", - " context.setPositions(positions)\n", - " context.setPeriodicBoxVectors(\n", - " openmm.Vec3(box, 0, 0),\n", - " openmm.Vec3(0, box, 0),\n", - " openmm.Vec3(0, 0, box),\n", - " )\n", - "\n", - " # Capture the true initial geometry before any minimisation\n", - " # (just in case the chain reaches substrate even before the 1st frame)\n", - " frames = []\n", - " state = context.getState(getPositions=True)\n", - " pos = state.getPositions(asNumpy=True).value_in_unit(unit.nanometer)\n", - " frames.append(pos.copy())\n", - "\n", - " # Cap iterations\n", - " openmm.LocalEnergyMinimizer.minimize(context,\n", - " tolerance=50, maxIterations=200)\n", - "\n", - " # ── Record frames ────────────────────────────────────────────────────────\n", - " for _ in range(int(n_frames)):\n", - " integrator.step(int(steps_per_frame))\n", - " state = context.getState(getPositions=True)\n", - " pos = state.getPositions(asNumpy=True).value_in_unit(unit.nanometer)\n", - " frames.append(pos.copy())\n", - "\n", - " return frames # n_frames + 1 entries (frame 0 = initial geometry)" - ] - }, - { - "cell_type": "markdown", - "id": "Bx7_OzWRr-l3", - "metadata": { - "id": "Bx7_OzWRr-l3" - }, - "source": [ - "## 4. Non-MD chain generation\n", - "In case you would not like to use molecular dynamics to generate the chains, it is also possible to skip the molecular dynamics and just use a simple 2D persistent walk to generate the DNA chains. The chains generated by this method might have some non physical configurations but the propoerties of the function can be modulated to achieve desired results." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "yXs0I0akr948", - "metadata": { - "id": "yXs0I0akr948" - }, - "outputs": [], - "source": [ - "def make_ring_2d_persistent_initial(\n", - " seed: int,\n", - " n_beads: int,\n", - " bond_length: float = BOND_LENGTH, # From Cell 1\n", - " persistence_bonds: float = PERSISTENCE_BONDS, # From Cell 1\n", - " angle_stiffness_mult: float = ANGLE_STIFNESS_MULT, # From Cell 1\n", - " # Small Gaussian noise for Z\n", - " z_std: float = 0.08,\n", - " # Low altitude for \"deposited\" look\n", - " base_z: float = 0.2,\n", - " # Acts as a soft per-step cap\n", - " angle_limit: float = np.pi/2,\n", - ") -> list[np.ndarray]:\n", - " \"\"\"\n", - " Generate a closed 2D persistent ring and return it as [coords].\n", - "\n", - " The function builds a periodic sequence of turning angles, smooths the\n", - " sequence to suppress sharp corners, and enforces total turning to ensure\n", - " the tangent field is compatible with a closed loop. The resulting curve is\n", - " resampled by arc length to maintain uniform bead spacing.\n", - "\n", - " Parameters\n", - " ----------\n", - " seed : int\n", - " Random seed for reproducibility.\n", - " num_beads : int\n", - " Number of beads in the polymer ring.\n", - " bond_length : float, optional\n", - " The desired distance between consecutive beads.\n", - " Defaults to BOND_LENGTH.\n", - " persistence_bonds : float, optional\n", - " Stiffness parameter; larger values result in a smoother ring with\n", - " longer directional memory. Defaults to PERSISTENCE_BONDS.\n", - " angle_stiffness_multiplier : float, optional\n", - " Multiplier for angular fluctuations; larger values result in\n", - " smaller fluctuations. Defaults to ANGLE_STIFNESS_MULT.\n", - " z_standard_deviation : float, optional\n", - " Standard deviation for the Gaussian noise applied to the z-axis.\n", - " Defaults to 0.08.\n", - " base_z : float, optional\n", - " The baseline altitude for the deposited coordinates. Defaults to 0.2.\n", - " angle_limit : float, optional\n", - " A soft cap on local turning increments (radians). Defaults to np.pi/2.\n", - "\n", - " Returns\n", - " -------\n", - " coords : np.ndarray\n", - " Array of shape (N, 3) containing the [x, y, z] coordinates\n", - "\n", - " Raises\n", - " ------\n", - " ValueError\n", - " If num_beads is less than 6 or if the generated ring has zero\n", - " contour length.\n", - "\n", - " Examples\n", - " --------\n", - " >>> coords = make_ring_2d_persistent_initial(seed=42)\n", - " >>> print(coords.shape)\n", - " (90, 3)\n", - "\n", - " \"\"\"\n", - "\n", - " rng = np.random.default_rng(int(seed))\n", - " n = int(n_beads)\n", - " if n < 6:\n", - " raise ValueError(\"n_beads must be at least\"\n", - " \"6 for a stable closed persistent ring.\")\n", - "\n", - " bond_length = float(bond_length)\n", - "\n", - " # ------------------------------------------------------------------\n", - " # 1) Build a periodic turning-angle process on the ring\n", - " # ------------------------------------------------------------------\n", - "\n", - " # larger persistence_bonds / angle_stiffness_mult => less angular noise\n", - " sigma_dtheta = (\n", - " np.sqrt(2.0 / max(float(persistence_bonds), 1.0))\n", - " / max(float(angle_stiffness_mult), 1e-6)\n", - " )\n", - "\n", - " # Raw local turning increments\n", - " dtheta = rng.normal(0.0, sigma_dtheta, size=n).astype(np.float64)\n", - " dtheta = np.clip(dtheta, -float(angle_limit), float(angle_limit))\n", - "\n", - " # Circular smoothing of turning increments to suppress sharp local corners.\n", - " # Stronger persistence / stiffness => broader smoothing.\n", - " smooth_width = int(np.clip(np.round(max(float(persistence_bonds), 1.0)\n", - " / 6.0), 1, 8))\n", - " if smooth_width > 0:\n", - " offsets = np.arange(-smooth_width, smooth_width + 1, dtype=np.float64)\n", - " kernel_sigma = max(smooth_width / 2.0, 1e-6)\n", - " kernel = np.exp(-0.5 * (offsets / kernel_sigma) ** 2)\n", - " kernel /= kernel.sum()\n", - "\n", - " dtheta_smooth = np.zeros_like(dtheta)\n", - " for shift, w in zip(offsets.astype(int), kernel):\n", - " dtheta_smooth += w * np.roll(dtheta, shift)\n", - " dtheta = dtheta_smooth\n", - "\n", - " # Enforce exact total turning of 2*pi for a closed planar ring.\n", - " # This avoids the nonphysical post hoc closure drift used before.\n", - " total_turn = dtheta.sum()\n", - " dtheta += (2.0 * np.pi - total_turn) / n\n", - "\n", - " # Re-clip gently after correction, then re-enforce total turning once more.\n", - " dtheta = np.clip(dtheta, -float(angle_limit), float(angle_limit))\n", - " dtheta += (2.0 * np.pi - dtheta.sum()) / n\n", - "\n", - " # ---------------------------------------------------------------------\n", - " # 2) Build periodic tangent angles and integrate to a dense closed path\n", - " # ---------------------------------------------------------------------\n", - " theta0 = rng.uniform(0.0, 2.0 * np.pi)\n", - " thetas = theta0 + np.cumsum(dtheta)\n", - "\n", - " # Use a dense piecewise-linear curve first; later resample uniformly.\n", - " tangents = np.stack([np.cos(thetas), np.sin(thetas)], axis=1)\n", - "\n", - " # Integrate unit-speed steps to get a provisional loop\n", - " xy = np.zeros((n, 2), dtype=np.float64)\n", - " xy[1:] = np.cumsum(tangents[:-1] * bond_length, axis=0)\n", - " end_error = (xy[-1] + tangents[-1] * bond_length) - xy[0]\n", - "\n", - " # Distribute closure correction through the bond vectors\n", - " bond_corr = end_error / n\n", - " bonds = tangents * bond_length - bond_corr[None, :]\n", - "\n", - " # Renormalize bond lengths back toward bond_length while keeping closure.\n", - " bond_norms = np.linalg.norm(bonds, axis=1)\n", - " good = bond_norms > 1e-12\n", - " bonds[good] *= (bond_length / bond_norms[good])[:, None]\n", - "\n", - " # Re-enforce closure after renormalization\n", - " bonds -= bonds.sum(axis=0, keepdims=True) / n\n", - "\n", - " # Reconstruct coordinates from corrected bonds\n", - " xy = np.zeros((n, 2), dtype=np.float64)\n", - " xy[1:] = np.cumsum(bonds[:-1], axis=0)\n", - "\n", - " # -----------------------------------------------------------------\n", - " # 3) Arc-length resample so bead spacing stays uniform and physical\n", - " # -----------------------------------------------------------------\n", - " closed_xy = np.vstack([xy, xy[0]])\n", - " seg = np.linalg.norm(np.diff(closed_xy, axis=0), axis=1)\n", - " s = np.concatenate([[0.0], np.cumsum(seg)])\n", - " total_len = s[-1]\n", - "\n", - " if total_len <= 1e-12:\n", - " raise ValueError(\"Degenerate ring generated;\"\n", - " \"total contour length is zero.\")\n", - "\n", - " target_s = np.linspace(0.0, total_len, n + 1)[:-1]\n", - "\n", - " x_resamp = np.interp(target_s, s, closed_xy[:, 0])\n", - " y_resamp = np.interp(target_s, s, closed_xy[:, 1])\n", - " xy = np.stack([x_resamp, y_resamp], axis=1)\n", - "\n", - " # Final contour-length normalization\n", - " # so mean bond length matches bond_length\n", - " final_bonds = np.roll(xy, -1, axis=0) - xy\n", - " mean_bond = np.mean(np.linalg.norm(final_bonds, axis=1))\n", - " if mean_bond > 1e-12:\n", - " xy *= (bond_length / mean_bond)\n", - "\n", - " # Center at origin\n", - " xy -= xy.mean(axis=0, keepdims=True)\n", - "\n", - " # ------------------------------------------------------------------\n", - " # 4) Assembly with preserved Gaussian z-noise logic\n", - " # ------------------------------------------------------------------\n", - " coords = np.zeros((n, 3), dtype=np.float32)\n", - " coords[:, 0] = xy[:, 0].astype(np.float32)\n", - " coords[:, 1] = xy[:, 1].astype(np.float32)\n", - " coords[:, 2] = rng.normal(loc=base_z,\n", - " scale=z_std, size=n).astype(np.float32)\n", - "\n", - " # Return as a list containing one frame to mimic run_md_relaxation output\n", - " return [coords]" - ] - }, - { - "cell_type": "markdown", - "id": "cell_md_04", - "metadata": { - "id": "cell_md_04" - }, - "source": [ - "## 5. MD Animation\n", - "Now we can visulize the Molecular dynamics simulation to see how the relaxation has worked.\n", - "\n", - "The function `show_md_animation` renders an interactive 3-D animation of MD frames in the notebook.\n", - "Running this cell will automatically generate and display the animation for a single deterministic chain (seed 0, default bead count)." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cell_code_04", - "metadata": { - "id": "cell_code_04" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generating initial ring and running MD (seed=0)…\n", - " CUDA unavailable: There is no registered Platform called \"CUDA\"\n", - "Using OpenCL platform.\n", - "MD done — 201 frames. Rendering animation…\n" - ] - }, - { - "ename": "NameError", - "evalue": "name 'anim_frames0' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[1;32mIn[48], line 94\u001b[0m\n\u001b[0;32m 90\u001b[0m anim_frames \u001b[38;5;241m=\u001b[39m run_md_relaxation(anim_coords0, seed\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m,\n\u001b[0;32m 91\u001b[0m n_frames\u001b[38;5;241m=\u001b[39mN_FRAMES,\n\u001b[0;32m 92\u001b[0m steps_per_frame\u001b[38;5;241m=\u001b[39mSTEPS_PER_FRAME)\n\u001b[0;32m 93\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMD done — \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mlen\u001b[39m(anim_frames)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m frames. Rendering animation…\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m---> 94\u001b[0m show_md_animation(\u001b[43manim_frames0\u001b[49m)\n", - "\u001b[1;31mNameError\u001b[0m: name 'anim_frames0' is not defined" - ] - } - ], - "source": [ - "def show_md_animation(\n", - " frames: list[np.ndarray],\n", - " interval_ms: int = 150,\n", - ") -> None:\n", - " \"\"\"\n", - " Renders an in-notebook HTML5 animation of MD frames.\n", - "\n", - " This function is used to visualize the molecular dynamics simulation\n", - " generated using the `run_md_relaxation` function.\n", - " A plane has been added for visualization purposes and the range of\n", - " absolute z values is also displayed.\n", - " This function is purely for visualisation and does not mutate any arrays.\n", - "\n", - " Parameters\n", - " ----------\n", - " frames : list\n", - " A list of coordinate arrays of shape (num_beads, 3).\n", - " interval_ms : int, optional\n", - " The time interval between frames in milliseconds. Defaults to 150.\n", - "\n", - " Returns\n", - " -------\n", - " None\n", - " The function calls `IPython.display.display` to render the\n", - " animation object directly in the notebook.\n", - "\n", - " Examples\n", - " --------\n", - " >>> show_md_animation(frames)\n", - "\n", - " \"\"\"\n", - "\n", - " frames = [np.asarray(f, dtype=np.float32) for f in frames]\n", - "\n", - " # Use only the first frame for x/y limits\n", - " # — avoids COM drift blowing the scale\n", - " first = frames[0]\n", - " xy_pad = 5.0\n", - " x_min, x_max = first[:, 0].min() - xy_pad, first[:, 0].max() + xy_pad\n", - " y_min, y_max = first[:, 1].min() - xy_pad, first[:, 1].max() + xy_pad\n", - "\n", - " # Clamp z: floor at -1 (just below substrate),\n", - " # ceiling from initial max + padding\n", - " z_min = -1.0\n", - " z_max = float(first[:, 2].max()) + 3.0\n", - "\n", - " x_plane = np.linspace(x_min, x_max, 2)\n", - " y_plane = np.linspace(y_min, y_max, 2)\n", - " X_plane, Y_plane = np.meshgrid(x_plane, y_plane)\n", - " Z_plane = np.zeros_like(X_plane)\n", - "\n", - " fig = plt.figure(figsize=(6, 6))\n", - " ax = fig.add_subplot(111, projection=\"3d\")\n", - "\n", - " def _set_axes():\n", - " ax.set_xlim(x_min, x_max)\n", - " ax.set_ylim(y_min, y_max)\n", - " ax.set_zlim(z_min, z_max)\n", - " ax.set_xlabel(\"x\"); ax.set_ylabel(\"y\"); ax.set_zlabel(\"z (nm)\")\n", - "\n", - " def init():\n", - " _set_axes()\n", - " return []\n", - "\n", - " def update(i):\n", - " ax.cla()\n", - " c = frames[i]\n", - " # Clip beads to visible z range for plotting so outliers don't distort\n", - " visible = (c[:, 2] >= z_min) & (c[:, 2] <= z_max)\n", - " cc = np.vstack([c, c[0]])\n", - " ax.plot(cc[:, 0], cc[:, 1], cc[:, 2], \"-\", linewidth=1)\n", - " ax.scatter(c[visible, 0], c[visible, 1], c[visible, 2], s=5)\n", - " ax.plot_surface(X_plane, Y_plane, Z_plane, alpha=0.2, color=\"cyan\")\n", - " _set_axes()\n", - " ax.set_title(f\"Frame {i}/{len(frames)-1} | \"\n", - " f\"z ∈ [{c[:,2].min():.1f}, {c[:,2].max():.1f}] nm\")\n", - " return []\n", - "\n", - " ani = animation.FuncAnimation(\n", - " fig, update, frames=len(frames), init_func=init,\n", - " interval=int(interval_ms), blit=False\n", - " )\n", - " plt.close(fig)\n", - " display(HTML(ani.to_jshtml()))\n", - "\n", - "\n", - "# ── Run animation automatically (deterministic seed) ─────────────────────────\n", - "print(\"Generating initial ring and running MD (seed=0)…\")\n", - "anim_coords0 = make_tangled_ring_initial(seed=1)\n", - "anim_frames = run_md_relaxation(anim_coords0, seed=1,\n", - " n_frames=N_FRAMES,\n", - " steps_per_frame=STEPS_PER_FRAME)\n", - "print(f\"MD done — {len(anim_frames)} frames. Rendering animation…\")\n", - "show_md_animation(anim_frames)" - ] - }, - { - "cell_type": "markdown", - "id": "cell_md_05", - "metadata": { - "id": "cell_md_05" - }, - "source": [ - "## 6. Height based AFM Rendering\n", - "Once we have the coordinates of the relaxed chain either via Molecular Dynamics or without, we can start to convert the coordinates into a DNA chain as if it were imaged via AFM. We mimic tip convolution using a spherical tip to get the desired appearance. \n", - "\n", - "Here we define all the AFM rendering utilities. All functions described here are essential for getting the 'look' of the DNA chains. Function descriptions are added to the functions themselves. Information necessary to build the masks later on is also preserved in these functions." - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "id": "cell_code_05", - "metadata": { - "id": "cell_code_05" - }, - "outputs": [], - "source": [ - "# ─────────────────────────────────────────────────────────────────────────────\n", - "# Low-level geometry helpers\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "\n", - "def _seg_intersect_2d(\n", - " p1: np.ndarray,\n", - " p2: np.ndarray,\n", - " q1: np.ndarray,\n", - " q2: np.ndarray,\n", - " eps: float = 1e-12,\n", - ") -> tuple[bool, np.ndarray | None, float | None, float | None]:\n", - " \"\"\"Calculates the strict 2-D intersection of 2 line segments.\n", - "\n", - " This function is one of the functions used for the creation of the\n", - " chain from the bead coordinates.\n", - " The intersection point is defined by the parameters t and u such that:\n", - " point = p1 + t * (p2 - p1) = q1 + u * (q2 - q1)\n", - "\n", - " Parameters\n", - " ----------\n", - " p1, p2 : np.ndarray\n", - " Start and end points of the first line segment.\n", - " q1, q2 : np.ndarray\n", - " Start and end points of the second line segment.\n", - " eps : float, optional\n", - " A small positive value for numerical stability. Defaults to 1e-12.\n", - "\n", - " Returns\n", - " -------\n", - " is_intersecting : bool\n", - " True if the segments intersect, False otherwise.\n", - " intersection_point : np.ndarray or None\n", - " The [x, y] coordinates of the intersection point, or None if no\n", - " intersection exists.\n", - " parameter_t : float or None\n", - " The interpolation parameter along the first segment, or None.\n", - " parameter_u : float or None\n", - " The interpolation parameter along the second segment, or None.\n", - "\n", - " Examples\n", - " --------\n", - " >>> hit, pt, t, u = _seg_intersect_2d(p1, p2, q1, q2)\n", - " >>> print(hit, pt, t, u)\n", - " False None None None\n", - "\n", - " \"\"\"\n", - "\n", - " p1 = np.asarray(p1, dtype=float); p2 = np.asarray(p2, dtype=float)\n", - " q1 = np.asarray(q1, dtype=float); q2 = np.asarray(q2, dtype=float)\n", - " r = p2 - p1; s = q2 - q1\n", - " rxs = r[0]*s[1] - r[1]*s[0]\n", - " if abs(rxs) < eps:\n", - " return False, None, None, None\n", - " qp = q1 - p1\n", - " t = (qp[0]*s[1] - qp[1]*s[0]) / rxs\n", - " u = (qp[0]*r[1] - qp[1]*r[0]) / rxs\n", - " if 0.0 <= t <= 1.0 and 0.0 <= u <= 1.0:\n", - " return True, p1 + t*r, t, u\n", - " return False, None, None, None\n", - "\n", - "\n", - "def _circ_sep(\n", - " n: int,\n", - " i: int,\n", - " j: int,\n", - ") -> int:\n", - " \"\"\"Circular distance between bead indices on a ring of n beads.\n", - "\n", - " This helper function determines the minimal separation between two beads\n", - " along the perimeter of the ring, accounting for the periodic boundary.\n", - " It is used to distinguish between beads that form physical crossings\n", - " and those that are simply sequential neighbors. This function is used\n", - " downstream for crossing calculations\n", - "\n", - " Parameters\n", - " ----------\n", - " n : int\n", - " Number of beads in the ring.\n", - " i, j : int\n", - " Indices of the two beads for which to calculate the separation.\n", - "\n", - " Returns\n", - " -------\n", - " int\n", - " The minimal distance between the two beads.\n", - "\n", - " Examples\n", - " --------\n", - " >>> d = _circ_sep(n, i, j)\n", - " >>> d.type\n", - " int\n", - "\n", - " \"\"\"\n", - "\n", - " d = abs(int(i) - int(j))\n", - " return min(d, n - d)\n", - "\n", - "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "# Structuring-element / grid helpers\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "\n", - "def disk_footprint(\n", - " r_px: float,\n", - ") -> np.ndarray:\n", - " \"\"\"Boolean circular footprint of radius r_px pixels.\n", - "\n", - " This function creates a 2D boolean mask representing a disk of a\n", - " specified radius. It is used to convert discrete bead coordinates into a\n", - " continuous chain structure by dilating each bead coordinate into a\n", - " disk-like structure. This is what builds the DNA chain radius.\n", - "\n", - " Parameters\n", - " ----------\n", - " r_px : float\n", - " Radius of the disk in pixels.\n", - "\n", - " Returns\n", - " -------\n", - " np.ndarray\n", - " A boolean array with True values inside the disk and false outside.\n", - "\n", - " Examples\n", - " --------\n", - " >>> footprint = disk_footprint(r_px)\n", - " >>> print(footprint.shape, footprint.dtype)\n", - " (5, 5) bool\n", - "\n", - " \"\"\"\n", - "\n", - " if r_px < 0.5:\n", - " return np.ones((1, 1), dtype=bool)\n", - " r = int(np.ceil(r_px))\n", - " y, x = np.ogrid[-r:r+1, -r:r+1]\n", - " return (x*x + y*y) <= r*r\n", - "\n", - "\n", - "def upsample_nn(\n", - " a: np.ndarray,\n", - " out_shape: tuple[int, int],\n", - ") -> np.ndarray:\n", - " \"\"\"Nearest-neighbour upsample array a to out_shape.\n", - "\n", - " This function increases the resolution of an input array (such as an AFM\n", - " height map or a boolean mask) by repeating elements. If the target\n", - " dimensions are not exact multiples of the input dimensions, the resulting\n", - " array is clipped to the specified target shape.\n", - "\n", - " Parameters\n", - " ----------\n", - " a : np.ndarray\n", - " Input array to be upsampled.\n", - " out_shape : tuple\n", - " Target shape of the upsampled array.\n", - "\n", - " Returns\n", - " -------\n", - " np.ndarray\n", - " Upsampled array of shape out_shape\n", - "\n", - " Examples\n", - " --------\n", - " >>> upsampled_array = upsample_nn(input_array, target_shape)\n", - " >>> print(upsampled_array.shape)\n", - " (target_shape[0], target_shape[1])\n", - "\n", - " \"\"\"\n", - "\n", - " ny_out, nx_out = out_shape\n", - " ny_in, nx_in = a.shape\n", - " if (ny_out, nx_out) == (ny_in, nx_in):\n", - " return a\n", - " sy = max(ny_out // ny_in, 1)\n", - " sx = max(nx_out // nx_in, 1)\n", - " a_up = a.repeat(sy, axis=0).repeat(sx, axis=1)\n", - " return a_up[:ny_out, :nx_out]\n", - "\n", - "\n", - "#internal render grid comes directly from extent and user nm_per_px\n", - "\n", - "def compute_internal_render_grid(\n", - " extent: tuple[float, float, float, float],\n", - " target_nm_per_px: float,\n", - " min_size: int = 16,\n", - ") -> tuple[int, int, float]:\n", - " \"\"\"Build the internal render grid from physical extent and user nm_per_px.\n", - "\n", - " This function determines the size of the grid for the resolution that the\n", - " user desires. It is based on values chosen for target_nm_per_px and\n", - " nm_per_pix. It also handles potential zero-division or negative resolution\n", - " values.\n", - "\n", - " Parameters\n", - " ----------\n", - " extent : tuple\n", - " boundaries of the simulation space\n", - " target_nm_per_px : float\n", - " desired resolution multiplied by a scaling factor in nm/pixel\n", - " min_size : int, optional\n", - " minimum size of the grid in pixels. Default 16\n", - "\n", - " Returns\n", - " -------\n", - " tuple\n", - " size of the grid\n", - "\n", - " Examples\n", - " --------\n", - " >>> nx, ny, p_nm_per_px = compute_internal_render_grid(extent,\n", - " target_nm_per_px)\n", - " >>> print(nx, ny, p_nm_per_px)\n", - " 256 256 0.5\n", - "\n", - " \"\"\"\n", - "\n", - " xmin, xmax, ymin, ymax = extent\n", - " width_nm = float(xmax - xmin)\n", - " height_nm = float(ymax - ymin)\n", - " p_nm_per_px = max(float(target_nm_per_px), 1e-6)\n", - " nx = max(int(min_size), int(np.ceil(width_nm / p_nm_per_px)) + 1)\n", - " ny = max(int(min_size), int(np.ceil(height_nm / p_nm_per_px)) + 1)\n", - " return nx, ny, p_nm_per_px\n", - "\n", - "\n", - "def resize_image_to_shape(\n", - " a: np.ndarray,\n", - " out_shape: tuple[int, int],\n", - " order: int =1,\n", - ") -> np.ndarray:\n", - " \"\"\"Resize 2D array a to out_shape using scipy.ndimage.zoom.\n", - "\n", - " This function utilizes `scipy.ndimage.zoom` to scale the input array. It\n", - " includes safety checks for edge-case padding and cropping to ensure the\n", - " output array matches the requested dimensions exactly.\n", - "\n", - " Parameters\n", - " ----------\n", - " a : np.ndarray\n", - " Input array to be resized.\n", - " out_shape : tuple\n", - " Target shape of the resized\n", - " order : int, optional\n", - " Order of the interpolation. Defaults to 1.\n", - "\n", - " Returns\n", - " -------\n", - " np.ndarray\n", - " Resized array of shape out_shape\n", - "\n", - " Examples\n", - " --------\n", - " >>> resized_array = resize_image_to_shape(input_array, target_shape)\n", - " >>> print(resized_array.shape)\n", - " (target_shape[0], target_shape[1])\n", - "\n", - " \"\"\"\n", - "\n", - " a = np.asarray(a)\n", - " out_shape = tuple(int(v) for v in out_shape)\n", - " if a.shape == out_shape:\n", - " return a.copy()\n", - " zoom_factors = (out_shape[0] / a.shape[0], out_shape[1] / a.shape[1])\n", - " out = zoom(a, zoom_factors, order=order, mode=\"nearest\",\n", - " prefilter=(order > 1))\n", - " out = out[:out_shape[0], :out_shape[1]]\n", - " if out.shape != out_shape:\n", - " pad_y = max(0, out_shape[0] - out.shape[0])\n", - " pad_x = max(0, out_shape[1] - out.shape[1])\n", - " out = np.pad(out, ((0, pad_y), (0, pad_x)), mode=\"edge\")\n", - " out = out[:out_shape[0], :out_shape[1]]\n", - " return out\n", - "\n", - "\n", - "def dna_shape(\n", - " radius_nm: float,\n", - " p_nm_per_px: float,\n", - " max_radius_px: int = 96,\n", - ")-> np.ndarray:\n", - " \"\"\"Hemispherical structuring element representing the DNA cross-section.\n", - "\n", - " This function generates a 2D height map representing the physical profile\n", - " of a DNA strand. Each pixel within the radius of the DNA is assigned a\n", - " height value based on the spherical-cap formula, representing the vertical\n", - " profile encountered during an AFM scan.\n", - "\n", - " Parameters\n", - " ----------\n", - " radius_nm : float\n", - " Radius of the disk in nanometers.\n", - " p_nm_per_px : float\n", - " Physical pixel size in nanometers.\n", - " max_radius_px : int, optional\n", - " Maximum radius in pixels. Defaults to 96.\n", - "\n", - " Returns\n", - " -------\n", - " np.ndarray\n", - " Height map of shape (2*R+1, 2*R+1)\n", - "\n", - " Example\n", - " -------\n", - " >>> height_map = dna_shape(radius_nm, p_nm_per_px)\n", - " >>> print(height_map.shape, height_map.dtype)\n", - " (5, 5) float32\n", - "\n", - " \"\"\"\n", - "\n", - " r_px = radius_nm / max(p_nm_per_px, 1e-12)\n", - " R = int(np.clip(np.ceil(r_px), 1, max_radius_px))\n", - " y, x = np.ogrid[-R:R+1, -R:R+1]\n", - " d2 = x*x + y*y\n", - " inside = d2 <= (r_px * r_px)\n", - " d_nm = np.sqrt(d2).astype(np.float32) * np.float32(p_nm_per_px)\n", - " structure = np.full((2*R+1, 2*R+1), -1e9, dtype=np.float32)\n", - " structure[inside] = np.sqrt(\n", - " np.maximum(radius_nm**2 - d_nm[inside]**2, 0.0)\n", - " ).astype(np.float32)\n", - " return inside.astype(bool), structure\n", - "\n", - "\n", - "def AFM_tip(\n", - " tip_radius_nm: float,\n", - " p_nm_per_px: float,\n", - " max_radius_px: int = 128,\n", - ") -> tuple[np.ndarray, np.ndarray]:\n", - " \"\"\"Spherical-cap structuring element representing the AFM tip geometry.\n", - "\n", - "\n", - " This function calculates the relative vertical profile of a spherical AFM\n", - " tip. The resulting height map is used to perform a morphological dilation\n", - " on the sample surface, simulating the physical interaction (convolution)\n", - " between the tip and the sample. The height is normalized so that the\n", - " tip apex is at 0.0.\n", - "\n", - " Parameters\n", - " ----------\n", - " tip_radius_nanometers : float\n", - " The physical radius of the AFM tip in nanometers.\n", - " nanometers_per_pixel : float\n", - " The spatial resolution of the simulation grid in nanometers per pixel.\n", - " maximum_radius_pixels : int, optional\n", - " A safety limit for the pixel radius of the structuring element to\n", - " prevent excessive memory consumption. Defaults to 128.\n", - "\n", - " Returns\n", - " -------\n", - " occupancy_mask : np.ndarray\n", - " A 2D boolean array representing the circular footprint of the tip.\n", - " height_structure_element : np.ndarray\n", - " A 2D float32 array containing the vertical profile offsets of the\n", - " spherical cap. Pixels outside the tip footprint are assigned a\n", - " large negative value (-1e9).\n", - "\n", - " Example\n", - " -------\n", - " >>> occupancy_mask, height_structure_element = AFM_tip(tip_radius_nm,\n", - " p_nm_per_px)\n", - " >>> print(occupancy_mask.shape, occupancy_mask.dtype)\n", - " (5, 5) bool\n", - "\n", - " \"\"\"\n", - "\n", - " Rpx = tip_radius_nm / max(p_nm_per_px, 1e-12)\n", - " R = int(np.clip(np.ceil(Rpx), 1, max_radius_px))\n", - " y, x = np.ogrid[-R:R+1, -R:R+1]\n", - " d2 = x*x + y*y\n", - " inside = d2 <= (Rpx * Rpx)\n", - " d_nm = np.sqrt(d2).astype(np.float32) * np.float32(p_nm_per_px)\n", - " structure = np.full((2*R+1, 2*R+1), -1e9, dtype=np.float32)\n", - " structure[inside] = (\n", - " np.sqrt(np.maximum(tip_radius_nm**2 - d_nm[inside]**2, 0.0))\n", - " - tip_radius_nm\n", - " ).astype(np.float32)\n", - " return inside.astype(bool), structure\n", - "\n", - "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "# Crossing boost\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "\n", - "def calculate_crossing_taper_weight(\n", - " idx_off: int,\n", - " w: int,\n", - " profile: str = \"gaussian\",\n", - " sigma: float | None = None,\n", - ") -> float:\n", - " \"\"\"Smooth weight in [0, 1] used to fade the crossing height boost.\n", - "\n", - " This function generates a weighting factor between 0 and 1 used to\n", - " gradually decrease the height offset applied to DNA segments near a\n", - " detected crossing. It ensures that the transition between the boosted\n", - " crossing region and the standard polymer chain is smooth.\n", - " There are 3 types of profiles possible to be applied\n", - " for smoothing a crossing, guassian, hemisphere, and linear.\n", - "\n", - " Parameters\n", - " ----------\n", - " idx_off : int\n", - " The distance in bead indices from the center of the crossing.\n", - " w : int\n", - " The number of beads on either side of the center over which the weight\n", - " should taper to zero.\n", - " profile : str, optional\n", - " The mathematical shape of the taper. Options are:\n", - " - 'gaussian': A smooth bell-shaped decay (recommended).\n", - " - 'hemisphere': A circular arc taper.\n", - " - 'linear': A simple linear ramp.\n", - " Defaults to 'gaussian'.\n", - " sigma : float, optional\n", - " The standard deviation for the Gaussian profile. If None, it is\n", - " automatically determined based on the window width.\n", - "\n", - " Returns\n", - " -------\n", - " float\n", - " A weighting factor in the range [0.0, 1.0].\n", - "\n", - " Examples\n", - " --------\n", - " >>> wt = calculate_crossing_taper_weight(idx_off, w)\n", - " >>> print(wt.dtype)\n", - " float32\n", - "\n", - " \"\"\"\n", - "\n", - " if w <= 0:\n", - " return 1.0\n", - " a = abs(idx_off)\n", - " if profile == \"linear\":\n", - " return 1.0 - (a / (w + 1.0))\n", - " if profile == \"hemisphere\":\n", - " x = a / (w + 1.0)\n", - " return float(np.sqrt(max(0.0, 1.0 - x*x)))\n", - " # gaussian (default)\n", - " if sigma is None:\n", - " sigma = max(1e-6, 0.5 * (w + 0.5))\n", - " g = float(np.exp(-(idx_off**2) / (2.0 * sigma**2)))\n", - " g_end = float(np.exp(-(w**2) / (2.0 * sigma**2)))\n", - " if g_end < 0.999:\n", - " g = float(np.clip((g - g_end) / (1.0 - g_end), 0.0, 1.0))\n", - " return g\n", - "\n", - "\n", - "def collect_intersections(\n", - " xy_nm: np.ndarray,\n", - " min_separation_beads: int = 12,\n", - " merge_radius_nm: float = 0.5,\n", - ")-> list[dict]:\n", - " \"\"\"Identify all self-intersections in a closed ring polyline.\n", - "\n", - " This function performs a brute-force search across all segment pairs of\n", - " the polyline to find crossings. It ignores adjacent segments, shared\n", - " vertices, and segments that are close to each other along the contour of\n", - " the ring. Detected intersections are subsequently clustered to handle\n", - " multi-segment vertex hits.\n", - "\n", - " Parameters\n", - " ----------\n", - "\n", - " xy_nm : np.ndarray\n", - " Array of shape (n, 2)\n", - " min_separation_beads : int, optional\n", - " Minimum separation between segments in beads. Defaults to 12.\n", - " merge_radius_nm : float, optional\n", - " Maximum separation between segments in nanometers. Defaults to 0.5.\n", - "\n", - " Returns\n", - " -------\n", - " list of dicts:\n", - " {pt_nm, seg_i, seg_j, t, u, n_hits}\n", - " list[dict]\n", - " A list of dictionaries, where each dictionary represents a unique\n", - " crossing and contains:\n", - " - \"pt_nm\": The [x, y] coordinates of the intersection.\n", - " - \"seg_i\": The index of the first segment involved.\n", - " - \"seg_j\": The index of the second segment involved.\n", - " - \"t\": Interpolation parameter along segment A.\n", - " - \"u\": Interpolation parameter along segment B.\n", - " - \"n_hits\": The number of raw intersections merged into this cluster.\n", - "\n", - " Examples\n", - " --------\n", - " >>> clusters = collect_intersections(xy_nm,\n", - " min_separation_beads=int(min_separation_beads),\n", - " merge_radius_nm=float(merge_radius_nm)\n", - " >>> print(clusters.type)\n", - " list[dicts]\n", - "\n", - " \"\"\"\n", - "\n", - " xy = np.asarray(xy_nm, dtype=float)\n", - " n = int(xy.shape[0])\n", - " raw = []\n", - " for i in range(n):\n", - " i2 = (i + 1) % n\n", - " p1, p2 = xy[i], xy[i2]\n", - " for j in range(i + 1, n):\n", - " j2 = (j + 1) % n\n", - " if i == j or i2 == j or j2 == i:\n", - " continue\n", - " if _circ_sep(n, i, j) < int(min_separation_beads):\n", - " continue\n", - " q1, q2 = xy[j], xy[j2]\n", - " hit, pt, t, u = _seg_intersect_2d(p1, p2, q1, q2)\n", - " if hit:\n", - " raw.append(dict(pt=np.array(pt, float),\n", - " seg_i=int(i), seg_j=int(j),\n", - " t=float(t), u=float(u)))\n", - "\n", - " clusters = merge_crossing_clusters(raw, merge_radius_nm=merge_radius_nm)\n", - " return clusters\n", - "\n", - "\n", - "def merge_crossing_clusters(\n", - " raw_list: list[dict],\n", - " merge_radius_nm: float = 0.5,\n", - ") -> list[dict]:\n", - " \"\"\"Group nearby raw intersection points into single averaged clusters.\n", - "\n", - " This function uses a greedy proximity-based algorithm to cluster\n", - " intersections that occur close to each other (e.g., where multiple\n", - " segments meet at a single vertex). It calculates the centroid for each\n", - " cluster and retains metadata from the first intersection encountered in\n", - " each group.\n", - "\n", - " Parameters\n", - " ----------\n", - " raw_list : list[dict]\n", - " A list of dictionaries containing raw intersection data. Each\n", - " dictionary must include the key \"point\" (a 2D numpy array).\n", - " merge_radius_nm : float, optional\n", - " The maximum Euclidean distance allowed between an intersection point\n", - " and a cluster's current centroid for it to be merged. Defaults to 0.5.\n", - "\n", - " Returns\n", - " -------\n", - " list[dict]\n", - "\n", - " Examples\n", - " --------\n", - " >>> clusters = merge_crossing_clusters(raw_list,\n", - " merge_radius_nm=float(merge_radius_nm))\n", - " >>> print(clusters.type)\n", - " list[dict]\n", - "\n", - " \"\"\"\n", - "\n", - " clusters = []\n", - " for r in raw_list:\n", - " pt = r[\"pt\"].astype(float)\n", - " placed = False\n", - " for c in clusters:\n", - " if np.linalg.norm(pt -\n", - " c[\"pt_sum\"] / c[\"n\"]) <= float(merge_radius_nm):\n", - " c[\"pt_sum\"] += pt\n", - " c[\"n\"] += 1\n", - " c[\"items\"].append(r)\n", - " placed = True\n", - " break\n", - " if not placed:\n", - " clusters.append({\"pt_sum\": pt.copy(), \"n\": 1, \"items\": [r]})\n", - "\n", - " out = []\n", - " for c in clusters:\n", - " pt = (c[\"pt_sum\"] / c[\"n\"]).astype(np.float32)\n", - " rep = c[\"items\"][0]\n", - " out.append(dict(\n", - " pt_nm = pt,\n", - " seg_i = int(rep[\"seg_i\"]),\n", - " seg_j = int(rep[\"seg_j\"]),\n", - " t = float(rep[\"t\"]),\n", - " u = float(rep[\"u\"]),\n", - " n_hits = int(c[\"n\"]),\n", - " ))\n", - " return out\n", - "\n", - "\n", - "def boost_crossings_intersections(\n", - " x_nm: np.ndarray,\n", - " y_nm: np.ndarray,\n", - " zc_nm: np.ndarray,\n", - " crossings: list[dict] | None = None,\n", - " min_separation_beads: int = 12,\n", - " boost_window_beads: int = 2,\n", - " guaranteed_offset_nm: float = 1.0,\n", - " boost_method: str = \"additive\",\n", - " boost_profile: str = \"gaussian\",\n", - " boost_sigma_beads: float | None = None,\n", - " far_clip_nm: float | None =2.5,\n", - " far_clip_window_beads: int = 12,\n", - " merge_radius_nm: float = 0.5,\n", - ") -> tuple[np.ndarray, list[dict]]:\n", - " \"\"\"Boost z-height at strand crossings so they are visually distinct.\n", - "\n", - " This function identifies self-intersections in a 2D projection and\n", - " physically separates the strands in 3D. For each crossing, it determines\n", - " which segment is 'on top' and raises its vertical profile using a tapered\n", - " window to ensure a realistic and visually distinct crossover point.\n", - " For each crossing it:\n", - " - Determines which strand is on top (higher z)\n", - " - Raises top-strand beads in a tapered window to at least\n", - " (bottom_max + guaranteed_offset_nm)\n", - " - Optionally clips non-crossing beads to far_clip_nm\n", - "\n", - " Parameters\n", - " ----------\n", - " x_nm : np.ndarray\n", - " The x-coordinates of the polymer chain.\n", - " y_nm : np.ndarray\n", - " The y-coordinates of the polymer chain.\n", - " zc_nm : np.ndarray\n", - " The initial z-coordinates of the polymer chain.\n", - " crossings : list[dict]\n", - " Pre-computed crossing data. If None, crossings are detected\n", - " automatically using `collect_polyline_intersections`.\n", - " min_separation_beads : int, optional\n", - " Minimum separation between segments in beads. Defaults to 12.\n", - " boost_window_beads : int, optional\n", - " The number of beads to boost. Defaults to 2.\n", - " guaranteed_offset_nm : float, optional\n", - " The minimum boost height in nanometers. Defaults to 1.0.\n", - " boost_method : str\n", - " The logic for height calculation\n", - " boost_profile : str\n", - " The shape of the tapering profile\n", - " boost_sigma_beads : float\n", - " The standard deviation for gaussian tapering\n", - " far_clip_nm : float\n", - " If applied caps the height of beads far from any crossing to this value.\n", - " far_clip_window_beads : int\n", - " The number of beads to clip.\n", - " merge_radius_nm : float\n", - " The maximum Euclidean distance for nearby raw intersections.\n", - "\n", - " Returns\n", - " -------\n", - " z : np.ndarray\n", - " The updated z-coordinates with crossings boosted.\n", - " crossing_info : list[dict]\n", - " Information regarding the identified and modified crossings.\n", - "\n", - " Examples\n", - " --------\n", - " >>> z, crossing_info = boost_crossings_intersections(x, y, z)\n", - " >>> print(z.shape, type(crossing_info))\n", - " (N,3) \n", - "\n", - " \"\"\"\n", - "\n", - " x = np.asarray(x_nm, dtype=np.float32)\n", - " y = np.asarray(y_nm, dtype=np.float32)\n", - " z = np.asarray(zc_nm, dtype=np.float32).copy()\n", - " n = int(z.shape[0])\n", - " if n < 5:\n", - " return z.astype(np.float32), []\n", - "\n", - " if crossings is None:\n", - " xy = np.stack([x, y], axis=1)\n", - " crossings = collect_intersections(\n", - " xy,\n", - " min_separation_beads=int(min_separation_beads),\n", - " merge_radius_nm=float(merge_radius_nm),\n", - " )\n", - "\n", - " def get_segment_indices(\n", - " center: int,\n", - " w: int,\n", - " ) -> np.ndarray:\n", - " \"\"\"\n", - " Calculate indices in a window around a center bead,\n", - " handling periodicity.\n", - "\n", - " Parameters\n", - " ----------\n", - " center : int\n", - " The index of the center bead.\n", - " w : int\n", - " The number of beads on either side of the center\n", - " to include.\n", - "\n", - " Returns\n", - " -------\n", - " np.ndarray\n", - "\n", - " \"\"\"\n", - "\n", - " return np.array([(center + k) % n for k in range(-w, w+1)],\n", - " dtype=np.int32)\n", - "\n", - " crossing_info = []\n", - " crossing_centers = []\n", - " w = int(boost_window_beads)\n", - "\n", - " for c in crossings:\n", - " i = int(c[\"seg_i\"]); j = int(c[\"seg_j\"])\n", - " i2 = (i + 1) % n; j2 = (j + 1) % n\n", - " ti = float(c.get(\"t\", 0.5)); uj = float(c.get(\"u\", 0.5))\n", - "\n", - " bead_i = i if ti < 0.5 else i2\n", - " bead_j = j if uj < 0.5 else j2\n", - " zi = float((1.0 - ti) * z[i] + ti * z[i2])\n", - " zj = float((1.0 - uj) * z[j] + uj * z[j2])\n", - "\n", - " top_center, bottom_center = (bead_i, bead_j) if zi >= zj else (bead_j,\n", - " bead_i)\n", - " top_seg = get_segment_indices(top_center, w)\n", - " bottom_seg = get_segment_indices(bottom_center, w)\n", - "\n", - " bl_max = float(z[bottom_seg].max())\n", - " tl_max = float(z[top_seg].max())\n", - "\n", - " if boost_method == \"absolute\":\n", - " target_height = bl_max + float(guaranteed_offset_nm)\n", - " else:\n", - " target_height = max(tl_max, bl_max) + float(guaranteed_offset_nm)\n", - "\n", - " for off in range(-w, w+1):\n", - " k = (top_center + off) % n\n", - " wt = float(calculate_crossing_taper_weight(off, w,\n", - " profile=boost_profile,\n", - " sigma=boost_sigma_beads))\n", - " z[k] = float((1.0 - wt) * z[k] + wt * max(z[k], target_height))\n", - "\n", - " crossing_centers.extend([int(top_center), int(bottom_center)])\n", - " crossing_info.append(dict(\n", - " pt_nm = np.asarray(c[\"pt_nm\"], dtype=np.float32),\n", - " seg_i = int(i),\n", - " seg_j = int(j),\n", - " top_center = int(top_center),\n", - " bottom_center= int(bottom_center),\n", - " ))\n", - "\n", - " # Clip beads far from any crossing\n", - " if crossing_centers and far_clip_nm is not None:\n", - " centers = np.array(crossing_centers, dtype=np.int32)\n", - " r = int(far_clip_window_beads)\n", - " for k in range(n):\n", - " d = int(np.min(np.minimum(np.abs(k - centers),\n", - " n - np.abs(k - centers))))\n", - " if d > r:\n", - " z[k] = min(z[k], float(far_clip_nm))\n", - "\n", - " return z.astype(np.float32), crossing_info\n", - "\n", - "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "# Main AFM renderer\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "\n", - "def create_z_based_afm(\n", - " coords: np.ndarray,\n", - " nx: int = 800,\n", - " ny: int = 800,\n", - " dna_diameter_nm: float = 2.0,\n", - " tip_radius_nm: float = 0.01,\n", - " max_height_nm: float = 6.0,\n", - " target_nm_per_px: float = 0.08,\n", - " max_radius_px: int = 96,\n", - " radius_shrink_px: float = 2.0,\n", - " final_blur_sigma_px: float = 0.20,\n", - " apply_edge_taper: bool = True,\n", - " taper_sigma_nm: float = 0.45,\n", - " taper_floor: float = 0.10,\n", - " add_center_ridge: bool = True,\n", - " ridge_sigma_nm: float = 0.25,\n", - " ridge_amp_nm: float = 0.25,\n", - " grain_nm: float = 0.0,\n", - " grain_sigma_px: float = 0.6,\n", - " grain_seed: int = 1,\n", - " enable_crossing_boost: bool = True,\n", - " min_separation_beads: int = 12,\n", - " boost_window_beads: int = 2,\n", - " guaranteed_offset_nm: float = 1.0,\n", - " boost_method: str = \"additive\",\n", - " boost_profile: str = \"gaussian\",\n", - " boost_sigma_beads: float | None = None,\n", - " crossings_precomputed: list[dict] | None = None,\n", - " far_clip_nm: float | None = 2.5,\n", - " far_clip_window_beads: int = 12,\n", - " return_crossing_info: bool = False,\n", - " return_masks: bool = True,\n", - " extent: tuple[float, float, float, float] | None = None,\n", - ") -> tuple[np.ndarray, dict | tuple]:\n", - " \"\"\"Master AFM renderer for simulating images from 3D coordinates.\n", - "\n", - " This pipeline projects 3D bead coordinates onto a 2D grid, manages\n", - " crossings, rasterizes the polymer backbone, applies morphological\n", - " dilations for DNA shape and AFM tip convolution, and adds realistic optical\n", - " and physical artifacts (taper, ridge, noise).\n", - " It follows the following steps:\n", - " 1. Project 3-D bead coords onto a 2-D effective grid\n", - " 2. Rasterise closed polyline with z-interpolation\n", - " 3. Optionally boost crossing heights (boost_crossings_intersections)\n", - " 4. Apply dna_shape (DNA cylindrical cross-section)\n", - " 5. Apply AFM_tip (tip-sample convolution)\n", - " 6. Clip, blur, edge-taper, center-ridge\n", - " 7. Optional synthetic grain noise\n", - " 8. Upsample to requested (nx, ny)\n", - "\n", - " Parameters\n", - " ----------\n", - " coords : np.ndarray\n", - " Array of shape (n, 3) containing x, y, z coordinates.\n", - " nx : int\n", - " Number of pixels in the x-direction.\n", - " ny : int\n", - " Number of pixels in the y-direction.\n", - " dna_diameter_nm : float\n", - " DNA diameter in nanometers.\n", - " tip_radius_nm : float\n", - " Tip radius in nanometers.\n", - " max_height_nm : float\n", - " Maximum height in nanometers.\n", - " target_nm_per_px : float\n", - " Target number of nanometers per pixel.\n", - " max_radius_px : int\n", - " Maximum radius in pixels.\n", - " radius_shrink_px : float\n", - " Radius shrinking factor.\n", - " final_blur_sigma_px : float\n", - " Final blur sigma in pixels.\n", - " apply_edge_taper : bool\n", - " Apply edge taper.\n", - " taper_sigma_nm : float\n", - " Taper sigma in nanometers.\n", - " taper_floor : float\n", - " Taper floor.\n", - " add_center_ridge : bool\n", - " Add center ridge.\n", - " ridge_sigma_nm : float\n", - " Ridge sigma in nanometers.\n", - " ridge_amp_nm : float\n", - " Ridge amplitude in nanometers.\n", - " grain_nm : float\n", - " Grain size in nanometers.\n", - " grain_sigma_px : float\n", - " Grain sigma in pixels.\n", - " grain_seed : int\n", - " Grain seed.\n", - " enable_crossing_boost : bool\n", - " Enable crossing boost.\n", - " min_separation_beads : int\n", - " Minimum separation between segments in beads.\n", - " boost_window_beads : int\n", - " The number of beads to boost.\n", - " guaranteed_offset_nm : float\n", - " The minimum boost height in nanometers.\n", - " boost_method : str\n", - " The logic for height calculation\n", - " boost_profile : str\n", - " The shape of the tapering profile\n", - " boost_sigma_beads : float\n", - " The standard deviation for gaussian tapering\n", - " crossings_precomputed : list[dict]\n", - " Pre-computed crossing data.\n", - " far_clip_nm : float\n", - " If applied caps the height of beads\n", - " far from any crossing to this value.\n", - " far_clip_window_beads : int\n", - " The number of beads to clip.\n", - " return_crossing_info : bool\n", - " Return crossing info.\n", - " return_masks : bool\n", - " Return masks.\n", - " extent : tuple[float, float, float, float]\n", - " Extent of the output image.\n", - "\n", - " Returns\n", - " -------\n", - " afm_image : np.ndarray\n", - " The simulated 2D AFM height map.\n", - " debug_dict : dict or tuple\n", - " A dictionary containing masks and metadata (if return_masks=True),\n", - " or a tuple containing the physical (xmin, xmax, ymin, ymax) extent.\n", - "\n", - " Examples\n", - " --------\n", - " >>> afm_image, debug_dict = create_z_based_afm(coords, nx=800, ny=800,\n", - " return_masks=True)\n", - " >>> print(afm_image.shape, type(debug_dict))\n", - " (800, 800) \n", - "\n", - " \"\"\"\n", - "\n", - " x, y, z = coords.T\n", - " if extent is None:\n", - " xmin, xmax = float(x.min() - 2), float(x.max() + 2)\n", - " ymin, ymax = float(y.min() - 2), float(y.max() + 2)\n", - " else:\n", - " xmin, xmax, ymin, ymax = extent\n", - "\n", - " nx_eff, ny_eff = int(nx), int(ny)\n", - " px_eff = (xmax - xmin) / max(nx_eff - 1, 1)\n", - " py_eff = (ymax - ymin) / max(ny_eff - 1, 1)\n", - " p_eff = 0.5 * (px_eff + py_eff)\n", - "\n", - " ix = np.clip(((x - xmin) / (xmax - xmin) * (nx_eff - 1)).astype(np.int32),\n", - " 0, nx_eff - 1)\n", - " iy = np.clip(((y - ymin) / (ymax - ymin) * (ny_eff - 1)).astype(np.int32),\n", - " 0, ny_eff - 1)\n", - "\n", - " zc = (z - z.min()).astype(np.float32)\n", - "\n", - " # ── Crossing boost ───────────────────────────────────────────────────────\n", - " crossing_info = []\n", - " if enable_crossing_boost:\n", - " zc, crossing_info = boost_crossings_intersections(\n", - " x.astype(np.float32), y.astype(np.float32), zc,\n", - " crossings=crossings_precomputed,\n", - " min_separation_beads=int(min_separation_beads),\n", - " boost_window_beads=int(boost_window_beads),\n", - " guaranteed_offset_nm=float(guaranteed_offset_nm),\n", - " boost_method=str(boost_method),\n", - " boost_profile=str(boost_profile),\n", - " boost_sigma_beads=boost_sigma_beads,\n", - " far_clip_nm=far_clip_nm,\n", - " far_clip_window_beads=int(far_clip_window_beads),\n", - " )\n", - "\n", - " # ── Rasterise polyline ───────────────────────────────────────────────────\n", - " z_line = np.zeros((ny_eff, nx_eff), dtype=np.float32)\n", - " line_mask = np.zeros((ny_eff, nx_eff), dtype=bool)\n", - " npts = len(ix)\n", - " for k in range(npts):\n", - " k2 = (k + 1) % npts\n", - " x0, y0, z0 = int(ix[k]), int(iy[k]), float(zc[k])\n", - " x1, y1, z1 = int(ix[k2]), int(iy[k2]), float(zc[k2])\n", - " n_seg = int(max(abs(x1 - x0), abs(y1 - y0)) + 1)\n", - " if n_seg <= 1:\n", - " z_line[y0, x0] = max(z_line[y0, x0], z0)\n", - " line_mask[y0, x0] = True\n", - " continue\n", - " xs = np.linspace(x0, x1, n_seg).astype(np.int32)\n", - " ys = np.linspace(y0, y1, n_seg).astype(np.int32)\n", - " zs = np.linspace(z0, z1, n_seg).astype(np.float32)\n", - " if xs.size > 1:\n", - " keep = np.ones(xs.shape[0], dtype=bool)\n", - " keep[1:] = (xs[1:] != xs[:-1]) | (ys[1:] != ys[:-1])\n", - " xs, ys, zs = xs[keep], ys[keep], zs[keep]\n", - " z_line[ys, xs] = np.maximum(z_line[ys, xs], zs)\n", - " line_mask[ys, xs] = True\n", - "\n", - " # ── DNA cap dilation ─────────────────────────────────────────────────────\n", - "\n", - " r_eff = max(0.5 * float(dna_diameter_nm), 0.2)\n", - " fp_dna, cap = dna_shape(r_eff, p_eff, max_radius_px=max_radius_px)\n", - " surface = grey_dilation(z_line, footprint=fp_dna,\n", - " structure=cap).astype(np.float32)\n", - " dna_region = grey_dilation(line_mask.astype(np.uint8), footprint=fp_dna)>0\n", - " surface[~dna_region] = 0.0\n", - "\n", - " # ── Tip convolution ──────────────────────────────────────────────────────\n", - " r_tip_px = float(tip_radius_nm) / max(p_eff, 1e-12)\n", - " if r_tip_px >= 0.5:\n", - " fp_tip, tip_struct = AFM_tip(\n", - " float(tip_radius_nm), p_eff, max_radius_px=max_radius_px)\n", - " surface = grey_dilation(surface, footprint=fp_tip,\n", - " structure=tip_struct).astype(np.float32)\n", - "\n", - " np.clip(surface, 0, max_height_nm, out=surface)\n", - " if final_blur_sigma_px > 0:\n", - " fbsp=float(final_blur_sigma_px)\n", - " surface = gaussian_filter(surface,\n", - " sigma=fbsp).astype(np.float32)\n", - "\n", - " # ── Edge taper + center ridge ────────────────────────────────────────────\n", - " if (apply_edge_taper or add_center_ridge) and np.any(line_mask):\n", - " dist_px = distance_transform_edt(~line_mask).astype(np.float32)\n", - " dist_nm = dist_px * np.float32(p_eff)\n", - " if apply_edge_taper:\n", - " sig = max(float(taper_sigma_nm), 1e-6)\n", - " factor = taper_floor + (1.0 - taper_floor) * np.exp(\n", - " -(dist_nm**2) / (2.0 * sig**2))\n", - " surface[dna_region] *= factor[dna_region]\n", - " if add_center_ridge and ridge_amp_nm > 0:\n", - " rs = max(float(ridge_sigma_nm), 1e-6)\n", - " ridge = np.exp(-(dist_nm**2) / (2.0 * rs**2))\n", - " surface[dna_region] += ridge_amp_nm * ridge[dna_region]\n", - " np.clip(surface, 0, max_height_nm, out=surface)\n", - "\n", - " # ── Synthetic grain ──────────────────────────────────────────────────────\n", - " if grain_nm and grain_nm > 0:\n", - " rng = np.random.default_rng(int(grain_seed))\n", - " n = rng.normal(0.0, 1.0, size=surface.shape).astype(np.float32)\n", - " if grain_sigma_px and grain_sigma_px > 0:\n", - " n = gaussian_filter(n,\n", - " sigma=float(grain_sigma_px)).astype(np.float32)\n", - " v=n[dna_region].std()\n", - " std = float(v) if np.any(dna_region) else float(n.std())\n", - " if std > 1e-9:\n", - " n /= np.float32(std)\n", - " surface[dna_region] *= (1.0 + np.float32(grain_nm) * n[dna_region])\n", - " np.clip(surface, 0, max_height_nm, out=surface)\n", - "\n", - " if return_masks:\n", - " debug = {\n", - " \"line_mask\": line_mask,\n", - " \"dna_region\": dna_region,\n", - " \"extent\": (xmin, xmax, ymin, ymax),\n", - " \"p_nm_per_px\": float(p_eff),\n", - " }\n", - " if return_crossing_info:\n", - " debug[\"crossings\"] = crossing_info\n", - " return surface, debug\n", - "\n", - " return surface, (xmin, xmax, ymin, ymax)" - ] - }, - { - "cell_type": "markdown", - "id": "cell_md_06", - "metadata": { - "id": "cell_md_06" - }, - "source": [ - "## 7. Noise Functions\n", - "Here we describe all the functions and utilities needed to extract and add the noise to our generated AFM_img. Depending on the choise of the user either:\n", - "\n", - "1. Bruker/Nanoscope `.spm` file parser and TopoStats-like noise extraction pipeline is used or,\n", - "2. If no blank `.spm` file is supplied, the notebook falls back to a PSD-based synthetic noise model.\n", - "\n", - "Note: Topostats is an AFM imaging software package developed at the University of Sheffield which is used for filtering of AFM data. We desribe functions that perform operations similar to Topostats to clean the noise data from the blank files before adding it to the AFM_img.\n", - "\n", - "### Mathematics of PSD-Matched Noise Synthesis\n", - "\n", - "All three methods in the code utilize **Frequency-Domain Synthesis**. The core principle is that the height field $z(x, y)$ can be generated from a target Power Spectral Density (PSD) using the inverse Fourier Transform.\n", - "\n", - "#### 1. General Synthesis Workflow\n", - "For an output image of shape $(N_y, N_x)$:\n", - "1. **Define a PSD**: Let $S(f_x, f_y)$ be the target power spectrum.\n", - "2. **Generate Complex Spectrum**: A complex field $Z(f_x, f_y)$ is created in the frequency domain:\n", - " $$Z(f_x, f_y) = \\sqrt{S(f_x, f_y)} \\cdot e^{i \\phi(f_x, f_y)}$$\n", - " where $\\phi$ is a random phase drawn from a uniform distribution $U(0, 2\\pi)$.\n", - "3. **Inverse Transform**: The spatial noise $z(x, y)$ is the real part of the Inverse Fast Fourier Transform (IFFT) of $Z$.\n", - "4. **RMS Scaling**: The image is normalized such that its standard deviation matches the target Root Mean Square (RMS) roughness." - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "id": "cell_code_06", - "metadata": { - "id": "cell_code_06" - }, - "outputs": [], - "source": [ - "# ─────────────────────────────────────────────────────────────────────────────\n", - "# Parsing the .spm file for height data\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "\n", - "def robust_range(a:np.ndarray | list) -> tuple[float, float, float]:\n", - " \"\"\"Calculate the 1st and 99th percentiles of finite values in an array.\n", - "\n", - " This function provides a robust measure of the data range by ignoring\n", - " extreme outliers (the top and bottom 1%) as well as non-finite values\n", - " (NaNs and infinities).\n", - "\n", - " Parameters\n", - " ----------\n", - " a : np.ndarray | list\n", - " The input data array to be evaluated.\n", - "\n", - " Returns\n", - " -------\n", - " tuple[float, float, float]\n", - " A tuple containing:\n", - " - percentile_1: The 1st percentile of the finite data.\n", - " - percentile_99: The 99th percentile of the finite data.\n", - " - robust_spread: The difference between the 99th and 1st percentiles.\n", - "\n", - " Examples\n", - " --------\n", - " >>> a,b,c = robust_range(img)\n", - " >>> print(a,b,c)\n", - " 262 1023 761\n", - "\n", - " \"\"\"\n", - "\n", - " a = np.asarray(a, dtype=np.float32)\n", - " p1, p99 = np.percentile(a[np.isfinite(a)], [1, 99])\n", - " return float(p1), float(p99), float(p99 - p1)\n", - "\n", - "\n", - "def looks_like_afm_height(img: np.ndarray) -> bool:\n", - " \"\"\"Determine if an image array represents a valid AFM height map.\n", - "\n", - " This function checks if the dynamic range of the image (excluding\n", - " extreme outliers) is finite, strictly positive, and within a physically\n", - " sane upper bound.\n", - "\n", - " Parameters\n", - " ----------\n", - " img : np.ndarray\n", - " The 2D array representing the simulated or real AFM height map.\n", - "\n", - " Returns\n", - " -------\n", - " bool\n", - " True if the image has a valid, finite, and positive dynamic range;\n", - " False otherwise (e.g., if the array is flat, infinite, or all NaNs).\n", - "\n", - " Examples\n", - " --------\n", - " >>> Flag = looks_like_afm_height(img)\n", - " >>> print(Flag)\n", - " True\n", - "\n", - " \"\"\"\n", - "\n", - " p1, p99, rng = robust_range(img)\n", - " return np.isfinite(rng) and 0 < rng <= 1e9\n", - "\n", - "\n", - "def maybe_to_nm(img: np.ndarray) -> tuple[np.ndarray, str]:\n", - " \"\"\"Auto-convert from metres to nm if values look metre-scale.\n", - "\n", - " This function is used to convert the height map from metres to nm if the\n", - " measured height is in metres.\n", - "\n", - " Parameters\n", - " ----------\n", - " img : np.ndarray\n", - " The 2D array representing the AFM height map.\n", - "\n", - " Returns\n", - " -------\n", - " A tuple consisting of:\n", - " - np.ndarray\n", - " The image after the converion of the height map if needed.\n", - " - str\n", - " either as is or meters to nanometers depending on passed values.\n", - "\n", - " Examples\n", - " --------\n", - " >>> img = maybe_to_nm(img)\n", - " >>> print(img.shape)\n", - " (800, 800)\n", - "\n", - " \"\"\"\n", - "\n", - " p1, p99, rng = robust_range(img)\n", - " mx = max(abs(p1), abs(p99))\n", - " if mx < 1e-3:\n", - " return img.astype(np.float32) * 1e9, \"meters->nm (auto)\"\n", - " return img.astype(np.float32), \"as-is (nm or counts)\"\n", - "\n", - "\n", - "def parse_blocks(\n", - " filename: str | Path,\n", - " max_blocks: int = 128,\n", - ") -> tuple[bytes, str, list[dict]]:\n", - " \"\"\"Read a .spm file and parse binary data-block metadata.\n", - "\n", - " This function extracts the ASCII header from a Scanning Probe Microscopy\n", - " (SPM) file, locates the metadata blocks for the image data, and parses the\n", - " structural parameters required to read the raw binary data.\n", - "\n", - " Parameters\n", - " ----------\n", - " filename: str | Path\n", - " The path to the .spm file to be parsed.\n", - " max_blocks: int\n", - " The maximum number of blocks to parse.\n", - "\n", - " Returns\n", - " -------\n", - " tuple[bytes, str, list[dict]]\n", - " A tuple containing:\n", - " - raw: The raw binary data from the .spm file.\n", - " - header: The ASCII header from the .spm file.\n", - " - uniq: A list of dictionaries containing the parsed block metadata.\n", - "\n", - " Raises\n", - " ------\n", - " RuntimeError\n", - " If no 'Data offset' strings are found in the header.\n", - "\n", - " Examples\n", - " --------\n", - " >>> raw, header, blocks = parse_blocks(filename)\n", - " >>> print(type(raw), type(header), type(blocks))\n", - " \n", - "\n", - " \"\"\"\n", - "\n", - " raw = open(filename, \"rb\").read()\n", - " i_end = raw.find(b\"\\x1a\")\n", - " if i_end == -1:\n", - " i_end = min(len(raw), 400_000)\n", - " header = raw[:i_end].decode(\"latin1\", errors=\"ignore\")\n", - "\n", - " matches = [m.start() for m in re.finditer(r\"Data offset\", header)]\n", - " if not matches:\n", - " raise RuntimeError(\"No 'Data offset' found in header.\")\n", - "\n", - " blocks = []\n", - " for k, pos in enumerate(matches[:max_blocks]):\n", - " win = header[max(0, pos-2500): min(len(header), pos+2500)]\n", - "\n", - " def grab_int(key):\n", - " m = re.search(rf\"{re.escape(key)}\\s*:\\s*([0-9]+)\", win)\n", - " return int(m.group(1)) if m else None\n", - "\n", - " def grab_float(key):\n", - " pattern = (\n", - " rf\"{re.escape(key)}\\s*:\\s*\"\n", - " r\"([+-]?[0-9]*\\.?[0-9]+(?:[Ee][+-]?[0-9]+)?)\"\n", - " )\n", - " m = re.search(pattern, win)\n", - " return float(m.group(1)) if m else None\n", - "\n", - " name_candidate = re.findall(r\"@[^:\\n\\r]{0,40}:\\s*([^\\n\\r]{1,80})\", win)\n", - " name = name_candidate[-1].strip() if name_candidate else None\n", - "\n", - " off = grab_int(\"Data offset\")\n", - " length = grab_int(\"Data length\")\n", - " bpp = grab_int(\"Bytes/pixel\")\n", - " nx_b = grab_int(\"Samps/line\")\n", - " ny_b = grab_int(\"Number of lines\")\n", - " zscale = grab_float(\"Z scale\")\n", - " zoff = grab_float(\"Z offset\")\n", - "\n", - " if None in (off, length, bpp, nx_b, ny_b):\n", - " continue\n", - " blocks.append(dict(name=name or f\"block_{k}\",\n", - " off=off, length=length, bpp=bpp,\n", - " nx=nx_b, ny=ny_b,\n", - " zscale=zscale, zoff=zoff))\n", - "\n", - " uniq, seen = [], set()\n", - " for b in blocks:\n", - " if b[\"off\"] not in seen:\n", - " uniq.append(b); seen.add(b[\"off\"])\n", - " if not uniq:\n", - " raise RuntimeError(\"Found 'Data offset' strings\"\n", - " \" but no parseable blocks.\")\n", - " return raw, header, uniq\n", - "\n", - "\n", - "def read_block_candidates(\n", - " raw: bytes,\n", - " b: dict,\n", - ") -> list[tuple[str, np.ndarray]]:\n", - " \"\"\"Decode a binary data block using all plausible NumPy data types.\n", - "\n", - " This function attempts to parse the binary blob using all logical dtypes\n", - " for the given bytes-per-pixel and applies physical Z-scaling to the\n", - " results.\n", - "\n", - " Parameters\n", - " ----------\n", - " raw : bytes\n", - " The raw binary data from the .spm file.\n", - " b : dict\n", - " The parsed block metadata.\n", - "\n", - " Returns\n", - " -------\n", - " list[tuple[str, np.ndarray]]\n", - " A list of candidate tuples. Each tuple contains:\n", - " - dtype_str: The string representation of the data type.\n", - " - image_array: The decoded image array.\n", - "\n", - " Raises\n", - " ------\n", - " Runtime error\n", - " - Truncated block.\n", - "\n", - " Examples\n", - " --------\n", - " >>> candidates = read_block_candidates(raw, b)\n", - " >>> print(type(candidates))\n", - " \n", - "\n", - " \"\"\"\n", - "\n", - " off, length, bpp = b[\"off\"], b[\"length\"], b[\"bpp\"]\n", - " nx_b, ny_b = b[\"nx\"], b[\"ny\"]\n", - " blob = raw[off:off+length]\n", - " if len(blob) < length:\n", - " raise RuntimeError(\"Truncated block.\")\n", - "\n", - " n = nx_b * ny_b\n", - " cands = []\n", - " dtype_map = {2: [\"i2\", \"u2\"],\n", - " 4: [\"i4\", \"f4\"],\n", - " 1: [\"u1\"]}\n", - " for dt in dtype_map.get(bpp, []):\n", - " arr = np.frombuffer(blob, dtype=np.dtype(dt), count=n)\n", - " if arr.size != n:\n", - " continue\n", - " cands.append((dt, arr.reshape(ny_b, nx_b).astype(np.float32)))\n", - "\n", - " out = []\n", - " for dt, img in cands:\n", - " z = img\n", - " if b.get(\"zscale\") is not None:\n", - " z = z * np.float32(b[\"zscale\"])\n", - " if b.get(\"zoff\") is not None:\n", - " z = z + np.float32(b[\"zoff\"])\n", - " out.append((dt, z))\n", - " return out\n", - "\n", - "\n", - "def choose_best_height_image(\n", - " raw: bytes,\n", - " blocks: list[dict],\n", - " verbose: bool = True,\n", - ")-> tuple[dict, np.ndarray]:\n", - " \"\"\"Evaluate all data blocks to find the most plausible AFM height map.\n", - "\n", - " This function iterate all blocks and dtype candidates and then picks the\n", - " one that:\n", - " - passes looks_like_afm_height\n", - " - has the highest log-variance score\n", - " (which is done to favor candidates with more topographical detail)\n", - "\n", - " Parameters\n", - " ----------\n", - " raw : bytes\n", - " The raw binary data from the .spm file.\n", - " blocks : list[dict]\n", - " The parsed block metadata.\n", - " verbose : bool\n", - " Whether to print diagnostics.\n", - "\n", - " Returns\n", - " -------\n", - " tuple[dict, np.ndarray]\n", - "\n", - " Raises\n", - " ------\n", - " RuntimeError\n", - " If no suitable block is found.\n", - "\n", - " Examples\n", - " --------\n", - " >>> b, img = choose_best_height_image(raw, blocks)\n", - " >>> print(type(b), type(img))\n", - " \n", - "\n", - " \"\"\"\n", - "\n", - " best, best_score = None, -np.inf\n", - " for b in blocks:\n", - " try:\n", - " for dt, img in read_block_candidates(raw, b):\n", - " if not looks_like_afm_height(img):\n", - " continue\n", - " p1, p99, rng = robust_range(img)\n", - " var = float(np.var(img))\n", - " score = np.log10(var + 1e-9) - 0.001 * max(rng - 1e6, 0)\n", - " if score > best_score:\n", - " best_score = score\n", - " best = (b, dt, img, (p1, p99, rng, var))\n", - " except Exception:\n", - " continue\n", - "\n", - " if best is None:\n", - " raise RuntimeError(\"Could not find a\"\n", - " \"plausible AFM height image decode.\")\n", - " b, dt, img, stats = best\n", - " if verbose:\n", - " p1, p99, rng, var = stats\n", - " print(f\"Chosen block: {b['name']!r} {b['ny']}x{b['nx']} \"\n", - " f\"bpp={b['bpp']} decode={dt}\")\n", - " print(f\"Robust p1={p1:.3g}, p99={p99:.3g}, \"\n", - " f\"range={rng:.3g}, var={var:.3g}\")\n", - " return b, img\n", - "\n", - "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "# TopoStats-like background / noise extraction\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "\n", - "def plane_remove(\n", - " z: np.ndarray,\n", - " mask: np.ndarray | None = None,\n", - ")-> np.ndarray:\n", - " \"\"\"Fit and subtract a first-order tilted plane from a 2D height map.\n", - "\n", - " This function performs background leveling by fitting a plane defined by\n", - " the equation z = ax + by + c to the image. If a mask is provided, the fit\n", - " is calculated only using the pixels where the mask is True (typically\n", - " representing the flat substrate).\n", - "\n", - " Parameters\n", - " ----------\n", - " z : np.ndarray\n", - " The 2D height map.\n", - " mask : np.ndarray | None, optional\n", - " A boolean mask of the same shape as z. If provided, the fit is\n", - " calculated only using the pixels where the mask is True.\n", - " This is useful for excluding features like DNA from the plane fit.\n", - " Defaults to None.\n", - "\n", - " Returns\n", - " -------\n", - " np.ndarray\n", - " The flattened height map.\n", - "\n", - " Examples\n", - " --------\n", - " >>> z_flat = plane_remove(z)\n", - " >>> print(z_flat.shape)\n", - " (800, 800)\n", - "\n", - " \"\"\"\n", - "\n", - " ny, nx = z.shape\n", - " Y, X = np.mgrid[0:ny, 0:nx]\n", - " A = np.c_[X.ravel(), Y.ravel(), np.ones(X.size)]\n", - " b = z.ravel()\n", - " if mask is not None:\n", - " m = mask.ravel().astype(bool)\n", - " A, b = A[m], b[m]\n", - " C, *_ = np.linalg.lstsq(A, b, rcond=None)\n", - " plane = (C[0]*X + C[1]*Y + C[2]).astype(np.float32)\n", - " return (z - plane).astype(np.float32)\n", - "\n", - "\n", - "def line_flatten_median(\n", - " z: np.ndarray,\n", - " mask: np.ndarray | None = None,\n", - ")-> np.ndarray:\n", - " \"\"\"Subtract per-row median (background pixels only if mask given).\n", - "\n", - " AFM images often exhibit horizontal stripes due to low-frequency noise or\n", - " z-axis drift during scanning. This function levels each scan line\n", - " independently by shifting its median value to zero.\n", - "\n", - " Parameters\n", - " ----------\n", - " z: np.ndarray\n", - " The 2D height map\n", - " mask: np.ndarray | None, optional\n", - " A boolean mask of the same shape as z. If provided,\n", - " the median is calculated only using the pixels where the mask is True.\n", - " This prevents features (like DNA) from biasing the\n", - " flattening of the background. Defaults to None.\n", - "\n", - " Returns\n", - " -------\n", - " np.ndarray\n", - " The flattened height map.\n", - "\n", - " Examples\n", - " --------\n", - " >>> z_flat = line_flatten_median(z)\n", - " >>> print(z_flat.shape)\n", - " (800, 800)\n", - "\n", - " \"\"\"\n", - "\n", - " out = z.astype(np.float32, copy=True)\n", - " for i in range(out.shape[0]):\n", - " if mask is None or not np.any(mask[i]):\n", - " med = np.median(out[i])\n", - " else:\n", - " med = np.median(out[i, mask[i]])\n", - " out[i] -= np.float32(med)\n", - " return out\n", - "\n", - "\n", - "def feature_mask(\n", - " z: np.ndarray,\n", - " smooth_sigma_px: float = 3.0,\n", - " thresh_sigma: float = 3.0,\n", - " dilate_px: int = 4,\n", - ")-> np.ndarray:\n", - " \"\"\"Detects topographical features as pixels deviating by a threshold.\n", - "\n", - " This function identifies pixels that deviate significantly from a smoothed\n", - " local background. It uses the Median Absolute Deviation (MAD) to estimate\n", - " the noise floor, making it robust against the features it is trying to\n", - " detect.\n", - "\n", - " Parameters\n", - " ----------\n", - " z : np.ndarray\n", - " The 2D height map.\n", - " smooth_sigma_px : float, optional\n", - " The smoothing width in pixels. Defaults to 3.0.\n", - " thresh_sigma : float, optional\n", - " The number of standard deviations above the median to consider a pixel\n", - " as a feature. Defaults to 3.0.\n", - " dilate_px : int, optional\n", - " The radius of curcular footprint to dilate the feature mask.\n", - " Defaults to 4.\n", - "\n", - " Returns\n", - " -------\n", - " np.ndarray\n", - " A boolean mask where true indicates a detected feature\n", - "\n", - " Examples\n", - " --------\n", - " >>> feat = feature_mask(z)\n", - " >>> print(feat.shape, feat.dtype)\n", - " (800, 800) bool\n", - "\n", - " \"\"\"\n", - "\n", - " z_s = gaussian_filter(z, sigma=float(smooth_sigma_px)).astype(np.float32)\n", - " resid = (z - z_s).astype(np.float32)\n", - " med = float(np.median(resid))\n", - " mad = float(np.median(np.abs(resid - med)))\n", - " sig = 1.4826 * mad if mad > 1e-12 else float(np.std(resid) + 1e-12)\n", - " feat = np.abs(resid - med) > (float(thresh_sigma) * sig)\n", - " if dilate_px and dilate_px > 0:\n", - " r = int(dilate_px)\n", - " yy, xx = np.ogrid[-r:r+1, -r:r+1]\n", - " fp = (xx*xx + yy*yy) <= r*r\n", - " feat = grey_dilation(feat.astype(np.uint8), footprint=fp) > 0\n", - " return feat\n", - "\n", - "\n", - "def inpaint_simple(\n", - " z: np.ndarray,\n", - " mask: np.ndarray,\n", - " smooth_sigma_px: float = 8.0,\n", - ") -> np.ndarray:\n", - " \"\"\"Replace masked regions with a smooth estimate of the local background.\n", - "\n", - " This function calculates a heavily blurred version of the original image to\n", - " serve as a background proxy and patches the masked areas with this\n", - " estimate.\n", - "\n", - " Parameters\n", - " ----------\n", - " z : np.ndarray\n", - " The 2D height map.\n", - " mask : np.ndarray\n", - " A boolean mask where True indicates pixels to be inpainted (features)\n", - " smooth_sigma_px : float, optional\n", - " The sigma value for the gaussian filter.\n", - " Higher value resutls in smoother inpainted images. Defaults to 8.0.\n", - "\n", - " Returns\n", - " -------\n", - " np.ndarray\n", - " The inpainted height\n", - "\n", - " Examples\n", - " --------\n", - " >>> z_bg = inpaint_simple(z, feat)\n", - " >>> print(z_bg.shape)\n", - " (800, 800)\n", - "\n", - " \"\"\"\n", - "\n", - " bg = gaussian_filter(z, sigma=float(smooth_sigma_px)).astype(np.float32)\n", - " out = z.copy()\n", - " out[mask] = bg[mask]\n", - " return out\n", - "\n", - "\n", - "def bandpass_noise(\n", - " z: np.ndarray,\n", - " low_sigma_px: float = 1.0,\n", - " high_sigma_px: float = 30.0,\n", - ") -> np.ndarray:\n", - " \"\"\"Performs bandpass filtering on the noise image.\n", - "\n", - " This function performs a bandpass filter by calculating the difference\n", - " between two Gaussian-blurred versions of the same image. It effectively\n", - " removes:\n", - " 1. High-frequency noise: Suppressed by the `low_sigma` blur.\n", - " 2. Low-frequency trends: (like tilt or bowing) Removed by subtracting\n", - " the `high_sigma` blur.\n", - "\n", - " Parameters\n", - " ----------\n", - " z : np.ndarray\n", - " The 2D height\n", - " low_sigma_px : float, optional\n", - " The sigma value for gaussian filter defining the high frequency cutoff.\n", - " Defaults to 1.0.\n", - " high_sigma_px : float, optional\n", - " The sigma value for gaussian filter defining the low frequency cutoff.\n", - " Defaults to 30.0.\n", - "\n", - " Returns\n", - " -------\n", - " np.ndarray\n", - " The bandpassed height map.\n", - "\n", - " Examples\n", - " --------\n", - " >>> tex = bandpass_noise(z)\n", - " >>> print(tex.shape)\n", - " (800, 800)\n", - "\n", - " \"\"\"\n", - "\n", - " low = gaussian_filter(z, sigma=float(low_sigma_px)).astype(np.float32)\n", - " high = gaussian_filter(z, sigma=float(high_sigma_px)).astype(np.float32)\n", - " return (low - high).astype(np.float32)\n", - "\n", - "\n", - "def extract_topostats_like_noise(\n", - " z_in: np.ndarray,\n", - " median_size: int = 3,\n", - " bg_quantile: float = 40.0,\n", - " feature_sigma_px: float = 3.0,\n", - " feature_thresh_sigma: float = 3.0,\n", - " feature_dilate_px: int = 4,\n", - " inpaint_sigma_px: float = 10.0,\n", - " band_low_sigma_px: float = 0.8,\n", - " band_high_sigma_px: float = 35.0,\n", - " target_rms_nm: float | None = None,\n", - " apply_plane_remove: bool = True,\n", - " apply_line_flatten: bool = True,\n", - " apply_bandpass: bool = True,\n", - ") -> tuple[float, np.ndarray, np.ndarray, np.ndarray]:\n", - " \"\"\"Execute the full noise-extraction pipeline on an AFM height map.\n", - "\n", - " This function isolates the pure substrate noise texture by leveling the\n", - " image (plane flatten and line flatten), masking out topographical features\n", - " (detect features), inpainting those regions, and applying a bandpass\n", - " filter.\n", - " The resulting image can be rescaled to a target RMS value.\n", - " The resulting texture can be used to augment synthetic datasets.\n", - "\n", - " Parameters\n", - " ----------\n", - " z_in : np.ndarray\n", - " The 2D height map.\n", - " median_size : int, optional\n", - " The size of the median filter to apply. Defaults to 3.\n", - " bg_quantile : float, optional\n", - " The quantile to used to generate a rough initial background guess for the\n", - " preliminary plane and line leveling. Defaults to 40.0.\n", - " feature_sigma_px : float, optional\n", - " The gaussian sigma for background estimation for the feature mask.\n", - " Defaults to 3.0.\n", - " feature_thresh_sigma : float, optional\n", - " The number of standard deviations above the median to consider a pixel as\n", - " a feature. Defaults to 3.0.\n", - " feature_dilate_px : int, optional\n", - " The radius of curcular footprint to dilate the feature mask. Defaults to\n", - " 4.\n", - " inpaint_sigma_px : float, optional\n", - " The sigma value for the gaussian filter. Higher value resutls in smoother\n", - " inpainted image. Defaults to 10.0.\n", - " band_low_sigma_px : float, optional\n", - " The sigma value for gaussian filter defining the high frequency cutoff.\n", - " Defaults to 0.8.\n", - " band_high_sigma_px : float, optional\n", - " The sigma value for gaussian filter defining the low frequency cutoff.\n", - " Defaults to 35.0.\n", - " target_rms_nm: float | None, optional\n", - " If provided, rescales the extracted noise textureto match this target RMS\n", - " roughness. Defaults to None.\n", - " apply_plane_remove : bool, optional\n", - " Whether to apply the plane remove step. Defaults to True.\n", - " apply_line_flatten : bool, optional\n", - " Whether to apply the line flatten step. Defaults to True.\n", - " apply_bandpass : bool, optional\n", - " Whether to apply the bandpass step. Defaults to True.\n", - "\n", - " Returns\n", - " -------\n", - " tuple[float, np.ndarray, np.ndarray, np.ndarray]\n", - " A tuple containing:\n", - " - rms_nm: The RMS roughness of the extracted noise texture.\n", - " - noise_texture: The extracted, zero mean noise texture.\n", - " - z_flat: The flattened height map.\n", - " - feature_mask: A boolean mask where true indicates a detected feature.\n", - "\n", - " Examples\n", - " --------\n", - " >>> rms_nm, noise_tex, z_flat, feat = extract_topostats_like_noise(z)\n", - " >>> print(rms_nm)\n", - " 0.06\n", - " >>> print(noise_tex.shape)\n", - " (800, 800)\n", - " >>> print(z_flat.shape)\n", - " (800, 800)\n", - " >>> print(feat.shape)\n", - " (800, 800)\n", - "\n", - " \"\"\"\n", - "\n", - " z = z_in.astype(np.float32)\n", - "\n", - " if median_size and median_size > 1:\n", - " z = median_filter(z, size=int(median_size)).astype(np.float32)\n", - "\n", - " q = np.percentile(z, float(bg_quantile))\n", - " bg0 = z <= q\n", - "\n", - " z_flat = z.copy()\n", - "\n", - " if apply_plane_remove:\n", - " z_flat = plane_remove(z_flat, mask=bg0)\n", - "\n", - " if apply_line_flatten:\n", - " z_flat = line_flatten_median(z_flat, mask=bg0)\n", - "\n", - " feat = feature_mask(\n", - " z_flat,\n", - " smooth_sigma_px=feature_sigma_px,\n", - " thresh_sigma=feature_thresh_sigma,\n", - " dilate_px=feature_dilate_px,\n", - " )\n", - "\n", - " z_bg = inpaint_simple(\n", - " z_flat,\n", - " feat,\n", - " smooth_sigma_px=inpaint_sigma_px,\n", - " )\n", - "\n", - " if apply_bandpass:\n", - " tex = bandpass_noise(\n", - " z_bg,\n", - " low_sigma_px=band_low_sigma_px,\n", - " high_sigma_px=band_high_sigma_px,\n", - " )\n", - " else:\n", - " tex = z_bg.astype(np.float32)\n", - "\n", - " bg = ~feat\n", - " rms = float(np.std(tex[bg])) if np.any(bg) else float(np.std(tex))\n", - "\n", - " if target_rms_nm is not None:\n", - " target = float(target_rms_nm)\n", - " if rms > 1e-12:\n", - " tex *= target / rms\n", - " rms = target\n", - "\n", - " return (\n", - " rms,\n", - " tex.astype(np.float32),\n", - " z_flat.astype(np.float32),\n", - " feat.astype(bool),\n", - " )\n", - "\n", - "\n", - "def tile_or_crop(\n", - " tex: np.ndarray,\n", - " out_shape: tuple[int, int],\n", - " seed: int | None = 0,\n", - ")-> np.ndarray:\n", - " \"\"\"Tile a texture array and extract a deterministic random crop.\n", - "\n", - " This function ensures that an extracted background noise texture can be\n", - " resized to fit any target simulated image size. If the texture is smaller\n", - " than the target, it is tiled (repeated) to cover the area. A random crop is\n", - " then taken to prevent obvious repeating patterns at the origin.\n", - "\n", - " Parameters\n", - " ----------\n", - " tex : np.ndarray\n", - " The 2D height map\n", - " out_shape : tuple[int, int]\n", - " The target output shape.\n", - " seed : int | None, optional\n", - " The random seed. Defaults to 0.\n", - "\n", - " Returns\n", - " -------\n", - " np.ndarray\n", - " The resized and cropped noise texture.\n", - "\n", - " Examples\n", - " --------\n", - " >>> tex = tile_or_crop(tex, (ny, nx))\n", - " >>> print(tex.shape)\n", - " (800, 800)\n", - "\n", - " \"\"\"\n", - "\n", - " ty, tx = tex.shape\n", - " oy, ox = out_shape\n", - " if (ty, tx) == (oy, ox):\n", - " return tex\n", - " tiled = np.tile(tex, (int(np.ceil(oy / ty)), int(np.ceil(ox / tx))))\n", - " rng = np.random.default_rng(seed)\n", - " y0 = int(rng.integers(0, tiled.shape[0] - oy + 1))\n", - " x0 = int(rng.integers(0, tiled.shape[1] - ox + 1))\n", - " return tiled[y0:y0+oy, x0:x0+ox].astype(np.float32)\n", - "\n", - "\n", - "def load_blank_spm_noise(\n", - " blank_path: str | Path,\n", - " target_rms_nm: float = 0.06,\n", - " verbose: bool = True,\n", - " apply_plane_remove: bool = USE_PLANE_REMOVE,\n", - " apply_line_flatten: bool = USE_LINE_FLATTEN,\n", - " apply_bandpass: bool = USE_BANDPASS_FILTER,\n", - ") -> tuple[float, np.ndarray, dict]:\n", - " \"\"\"Load an SPM file and extract a calibrated background noise texture.\n", - "\n", - " This high-level function handles the full lifecycle of noise extraction:\n", - " 1. Parsing the Bruker .spm binary and metadata.\n", - " 2. Heuristically selecting the best height channel.\n", - " 3. Calibrating raw digital units to physical nanometers.\n", - " 4. Leveling, masking, and bandpass-filtering the substrate noise.\n", - "\n", - " Parameters\n", - " ----------\n", - " blank_path : str | Path\n", - " The path to the blank .spm file.\n", - " target_rms_nm : float, optional\n", - " The target RMS roughness of the extracted noise texture.\n", - " Defaults to 0.06.\n", - " verbose : bool, optional\n", - " Whether to print progress messages and diagnostic statistics.\n", - " Defaults to True.\n", - "\n", - " Returns\n", - " -------\n", - " tuple[float, np.ndarray, dict]\n", - " A tuple containing:\n", - " - rms_nm: The RMS roughness of the extracted noise texture.\n", - " - noise_texture: The extracted, zero mean noise texture.\n", - " - diagnostics_dict: A dictionary containing diagnostic information.\n", - "\n", - " Examples\n", - " --------\n", - " >>> rms_nm, noise_tex, diag = load_blank_spm_noise(blank_path)\n", - " >>> print(rms_nm)\n", - " 0.06\n", - " >>> print(noise_tex.shape)\n", - " (800, 800)\n", - " >>> print(diag['flattened'].shape)\n", - " (800, 800)\n", - " >>> print(diag['feature_mask'].shape)\n", - " (800, 800)\n", - "\n", - " \"\"\"\n", - "\n", - " raw, header, blocks = parse_blocks(blank_path)\n", - " b, img0 = choose_best_height_image(raw, blocks, verbose=verbose)\n", - " img_nm, unit_note = maybe_to_nm(img0)\n", - " if verbose:\n", - " print(\"Loaded via parser:\", img0.shape, \"| units:\", unit_note)\n", - "\n", - " rms_nm, noise_tex, z_flat, feat = extract_topostats_like_noise(\n", - " img_nm,\n", - " median_size=3,\n", - " bg_quantile=45,\n", - " feature_sigma_px=3.0,\n", - " feature_thresh_sigma=3.0,\n", - " feature_dilate_px=6,\n", - " inpaint_sigma_px=10.0,\n", - " band_low_sigma_px=0.7,\n", - " band_high_sigma_px=40.0,\n", - " target_rms_nm=target_rms_nm,\n", - " )\n", - " diag = {\"flattened\": z_flat, \"feature_mask\": feat,\n", - " \"height_nm\": img_nm, \"unit_note\": unit_note}\n", - " if verbose:\n", - " print(f\"Extracted noise RMS (bg): {rms_nm:.4f} nm | \"\n", - " f\"tex shape: {noise_tex.shape}\")\n", - " return rms_nm, noise_tex, diag\n", - "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "# PSD-based fallback noise synthesis\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "\n", - "TARGET_SHAPE = (NY, NX) #To match the shape of the AFM_img\n", - "#Safety buffer to ensure no division by 0 or square roots producing NaN values\n", - "EPS = 1e-12\n", - "\n", - "\n", - "def load_model(\n", - " path: str | Path = MODEL_PATH,\n", - ") -> dict[str, np.ndarray]:\n", - " \"\"\"\n", - " Load the Power Spectral Density (PSD) noise model\n", - " from a compressed archive.\n", - "\n", - " The model typically contains the statistical distribution of substrate\n", - " roughness in the frequency domain, allowing for the generation of\n", - " synthetic noise that matches the 'color' and texture of the substrate.\n", - "\n", - " Parameters\n", - " ----------\n", - " path : str | Path, optional\n", - " The path to the compressed archive containing the PSD model.\n", - "\n", - " Returns\n", - " -------\n", - " dict[str, np.ndarray]\n", - " A dictionary containing the PSD model components namely:\n", - " - \"log_psd_mean\": The mean of the log-transformed radial PSD.\n", - " - \"log_psd_std\": The standard deviation of the\n", - " log-transformed radial PSD.\n", - " - \"radial_freq\": The spatial frequency coordinates.\n", - " - \"rms_values_nm\": RMS values associated with the training set.\n", - "\n", - " Examples\n", - " --------\n", - " >>> model = load_model()\n", - " >>> print(type(model))\n", - " \n", - "\n", - " \"\"\"\n", - "\n", - " data = np.load(path)\n", - " return {\n", - " \"log_psd_mean\": data[\"log_psd_mean\"].astype(np.float32),\n", - " \"log_psd_std\": data[\"log_psd_std\"].astype(np.float32),\n", - " \"radial_freq\": data[\"radial_freq\"].astype(np.float32),\n", - " \"rms_values_nm\": data[\"rms_values_nm\"].astype(np.float32),\n", - " }\n", - "\n", - "\n", - "def generate_noise(\n", - " seed: int,\n", - " target_shape: tuple[int, int] = TARGET_SHAPE,\n", - " target_rms_nm: float | None = TARGET_NOISE_RMS_NM,\n", - " method: str = \"mean_full2d\",\n", - " std_scale: float = 1.0,\n", - " model: dict | None = None,\n", - " model_path: str | Path | None = MODEL_PATH,\n", - ") -> np.ndarray:\n", - " \"\"\"\n", - " Generate a single random AFM-like background noise image from the PSD.\n", - "\n", - " This function performs Fourier synthesis to create textures that match\n", - " the spatial frequency characteristics of the PSD model provided.\n", - "\n", - " Parameters\n", - " ----------\n", - " seed : int\n", - " RNG seed for reproducibility.\n", - " target_shape : tuple[int, int]\n", - " Output image shape (rows, cols).\n", - " The PSD is resized automatically if it differs\n", - " from the shape used when building the model. Defaults to TARGET_SHAPE.\n", - " target_rms_nm : float | None\n", - " RMS amplitude in nm.\n", - " If None a value is randomly taken from the blank-file ensemble.\n", - " Defaults to TARGET_NOISE_RMS_NM.\n", - " method : str\n", - " 'mean_full2d' -- mean log-PSD;\n", - " variance comes only from random phase (recommended).\n", - " 'lognormal_full2d' -- Samples a new PSD\n", - " from the log-normal distribution. (more sample to sample variation)\n", - " 'empirical_radial' -- isotropic synthesis from the mean radial PSD.\n", - " std_scale : float\n", - " Multiplier for the PSD on log_psd_std\n", - " for lognormal method (>1 -> more variation).\n", - " model : dict | None\n", - " Pre-loaded model dict. If None, loaded from model_path on each call.\n", - " model_path : str | Path | None\n", - " Path to the .npz file (used only when model is None).\n", - "\n", - " Returns\n", - " -------\n", - " z: np.ndarray\n", - "\n", - " Raises\n", - " ------\n", - " ValueError\n", - " If an unknown method is provided.\n", - "\n", - " Examples\n", - " --------\n", - " >>> z = generate_noise(seed=42)\n", - " >>> print(z.shape)\n", - " (800, 800)\n", - "\n", - " \"\"\"\n", - "\n", - " if model is None:\n", - " model = load_model(model_path)\n", - "\n", - " rng = np.random.default_rng(int(seed))\n", - " out_shape = tuple(target_shape)\n", - "\n", - " if method == \"mean_full2d\":\n", - " psd_sample = np.exp(model[\"log_psd_mean\"])\n", - "\n", - " elif method == \"lognormal_full2d\":\n", - " mu= model[\"log_psd_mean\"]\n", - " noise = rng.standard_normal(mu.shape).astype(np.float32)\n", - " psd_sample = np.exp(mu + std_scale * mu * noise)\n", - "\n", - " elif method == \"empirical_radial\":\n", - " mu = model[\"log_psd_mean\"]\n", - " radial_psd = np.exp(mu.mean(axis=1))\n", - " radial_freq_for_interp = np.abs(np.fft.fftfreq(mu.shape[0], d=1.0))\n", - "\n", - " fy = np.fft.fftfreq(out_shape[0], d=1.0)\n", - " fx = np.fft.rfftfreq(out_shape[1], d=1.0)\n", - " fy2d, fx2d = np.meshgrid(fy, fx, indexing=\"ij\")\n", - " kr = np.sqrt(fy2d ** 2 + fx2d ** 2)\n", - "\n", - " psd_sample = np.interp(\n", - " kr.ravel(),\n", - " radial_freq_for_interp,\n", - " radial_psd,\n", - " left=float(radial_psd[0]),\n", - " right=float(radial_psd[-1]),\n", - " ).reshape(kr.shape).astype(np.float32)\n", - "\n", - " else:\n", - " raise ValueError(\n", - " f\"Unknown method {method!r}. \"\n", - " \"Choose 'mean_full2d', 'lognormal_full2d', or 'empirical_radial'.\"\n", - " )\n", - "\n", - " psd_ny, psd_nx = psd_sample.shape\n", - " out_ny, out_nx = out_shape\n", - " rfft_nx = out_nx // 2 + 1\n", - "\n", - " if (psd_ny, psd_nx) != (out_ny, rfft_nx):\n", - " from scipy.ndimage import zoom\n", - " psd_sample = zoom(psd_sample, (out_ny / psd_ny, rfft_nx / psd_nx),\n", - " order=1)\n", - "\n", - " psd_sample = psd_sample.astype(np.float32)\n", - "\n", - " phase = rng.uniform(0.0, 2.0 * np.pi, size=psd_sample.shape)\n", - " spec = np.sqrt(np.maximum(psd_sample, EPS)) * np.exp(1j * phase)\n", - "\n", - " z = np.fft.irfft2(spec, s=out_shape).real.astype(np.float32)\n", - " z -= np.float32(np.mean(z))\n", - " rmsv = model[\"rms_values_nm\"]\n", - " trmsf = float(target_rms_nm)\n", - " target = float(rng.choice(rmsv)) if target_rms_nm is None else trmsf\n", - " cur = float(np.std(z))\n", - " if cur > EPS:\n", - " z *= target / cur\n", - "\n", - " return z\n", - "\n", - "def random_transform_noise_texture(\n", - " tex: np.ndarray,\n", - " seed: int,\n", - ") -> np.ndarray:\n", - " \"\"\"Apply a deterministic random affine transform to a noise texture.\n", - "\n", - " This function generates a reproducible random transformation of an input\n", - " texture using the provided seed. The transformation includes rotation,\n", - " anisotropic scaling, translation, optional vertical and horizontal flips,\n", - " and a final amplitude jitter.\n", - " It is intended to produce visually distinct noise realizations from a\n", - " single acquired blank SPM texture, while preserving the overall texture\n", - " statistics.\n", - "\n", - " Parameters\n", - " ----------\n", - " tex: np.ndarray\n", - " Input noise texture of shape (H, W).\n", - " seed: int\n", - " Random seed controlling the random transformation.\n", - "\n", - " Returns\n", - " -------\n", - " out: np.ndarray\n", - " Transformed noise texture of shape (H, W).\n", - "\n", - " Examples\n", - " --------\n", - " >>> transformed = random_transform_noise_texture(tex, seed=42)\n", - " transformed\n", - " >>> transformed.shape == tex.shape\n", - " True\n", - "\n", - " \"\"\"\n", - "\n", - " rng = np.random.default_rng(int(seed))\n", - " tex = np.asarray(tex, dtype=np.float32)\n", - "\n", - " theta = np.deg2rad(float(rng.uniform(0.0, 360.0)))\n", - " base_scale = float(rng.uniform(0.85, 1.15))\n", - " anis = float(rng.uniform(0.85, 1.15))\n", - " sx, sy = base_scale * anis, base_scale / anis\n", - "\n", - " c, s = float(np.cos(theta)), float(np.sin(theta))\n", - " A = np.array([[c*sx, -s*sy], [s*sx, c*sy]], dtype=np.float32)\n", - " M = np.linalg.inv(A).astype(np.float32)\n", - "\n", - " h, w = tex.shape\n", - " center = np.array([(h-1)/2.0, (w-1)/2.0], dtype=np.float32)\n", - " t = np.array([float(rng.uniform(-0.15*h, 0.15*h)),\n", - " float(rng.uniform(-0.15*w, 0.15*w))], dtype=np.float32)\n", - " offset = center - M @ (center + t)\n", - "\n", - " out = affine_transform(tex, matrix=M, offset=offset,\n", - " output_shape=tex.shape, order=1,\n", - " mode=\"wrap\", prefilter=False).astype(np.float32)\n", - "\n", - " if bool(rng.integers(0, 2)):\n", - " out = out[::-1, :]\n", - " if bool(rng.integers(0, 2)):\n", - " out = out[:, ::-1]\n", - " out *= float(rng.uniform(0.90, 1.10))\n", - " return out.astype(np.float32)\n", - "\n", - "\n", - "def sample_noise_image(\n", - " noise_source: str,\n", - " noise_asset: dict | np.ndarray | None,\n", - " seed: int,\n", - " out_shape: tuple[int, int],\n", - " target_rms_nm: float | None,\n", - ") -> np.ndarray | None:\n", - " \"\"\"Return a per-sample noise image from either blank.spm or PSD fallback.\n", - "\n", - " Parameters\n", - " ----------\n", - " noise_source : str\n", - " 'blank_spm' or 'psd_model'\n", - " noise_asset : dict | np.ndarray | None\n", - " If 'blank_spm', this is the 2D texture array.\n", - " If 'psd_model', this is the dictionary containing PSD statistics.\n", - " seed : int\n", - " RNG seed for reproducibility.\n", - " out_shape : tuple[int, int]\n", - " The (rows, cols) of the desired height map.\n", - " target_rms_nm : float | None\n", - " If provided, rescales the extracted noise texture\n", - " to match this target RMS roughness.\n", - "\n", - " Returns\n", - " -------\n", - " np.ndarray | None\n", - " The per-sample noise image or None if disabled.\n", - "\n", - " Examples\n", - " --------\n", - " >>> noise_tex = sample_noise_image(noise_source, noise_asset,\n", - " seed, out_shape, target_rms_nm)\n", - " >>> print(noise_tex.shape)\n", - " (800, 800)\n", - "\n", - " \"\"\"\n", - "\n", - " if noise_asset is None:\n", - " return None\n", - "\n", - " if noise_source == \"blank_spm\":\n", - " noise_tex = random_transform_noise_texture(noise_asset, seed=seed)\n", - " return tile_or_crop(noise_tex, out_shape, seed=seed).astype(np.float32)\n", - "\n", - " if noise_source == \"psd_model\":\n", - " return generate_noise(\n", - " seed=seed,\n", - " target_shape=out_shape,\n", - " target_rms_nm=target_rms_nm,\n", - " method=PSD_NOISE_METHOD,\n", - " std_scale=PSD_NOISE_STD_SCALE,\n", - " model=noise_asset,\n", - " ).astype(np.float32)\n", - "\n", - " return None\n" - ] - }, - { - "cell_type": "markdown", - "id": "cell_md_07", - "metadata": { - "id": "cell_md_07" - }, - "source": [ - "## 8. DNA Ground-Truth Mask\n", - "Now that we have produced the AFM_img and added noise to it, we can generate the ground truth mask for the DNA chain, which is useful for training of machine learning models for classification and segmentation.\n", - "\n", - "The functions described here perform rasterization of the closed bead polyline into a binary mask using the same coordinate mapping as the AFM renderer, then dilates with a disk footprint. So, it takes the coordinates that are being used to generate the chain, and uses those to create the mask, thus removing any influence of the noise on the mask.\n", - "\n", - "We also dilate the mask by a value of **DNA_MASK_DILATE_PX** to ensure that the mask has enough width for optimal training." - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "id": "cell_code_07", - "metadata": { - "id": "cell_code_07" - }, - "outputs": [], - "source": [ - "def nm_to_px(\n", - " coords_xy_nm: np.ndarray,\n", - " extent: tuple[float, float, float, float],\n", - " nx: int,\n", - " ny: int,\n", - ") -> tuple[np.ndarray, np.ndarray]:\n", - " \"\"\"Map (x, y) coordinates in nanometres to integer pixel indices (ix, iy).\n", - "\n", - " Linearly maps each coordinate from the physical extent to the discrete\n", - " pixel grid, then clips to valid index bounds.\n", - "\n", - " Parameters\n", - " ----------\n", - " coords_xy_nm : np.ndarray\n", - " The (x, y) coordinates in nanometres.\n", - " extent : tuple[float, float, float, float]\n", - " The physical extent (xmin, xmax, ymin, ymax) in nanometres.¨\n", - " nx : int\n", - " The number of pixels in the x-direction.\n", - " ny : int\n", - " The number of pixels in the y-direction.\n", - "\n", - " Returns\n", - " -------\n", - " ix, iy : tuple[np.ndarray, np.ndarray]\n", - " The integer pixel indices which are:\n", - " - ix: The x-coordinate indices.\n", - " - iy: The y-coordinate indices.\n", - "\n", - " Examples\n", - " --------\n", - " >>> ix, iy = nm_to_px(coords_xy_nm, extent, nx, ny)\n", - " >>> print(ix.dtype, iy.dtype)\n", - " int32 int32\n", - "\n", - " \"\"\"\n", - "\n", - " x = coords_xy_nm[:, 0]; y = coords_xy_nm[:, 1]\n", - " xmin, xmax, ymin, ymax = extent\n", - " ix = np.clip(((x - xmin) / (xmax - xmin) * (nx - 1)).astype(np.int32),\n", - " 0, nx - 1)\n", - " iy = np.clip(((y - ymin) / (ymax - ymin) * (ny - 1)).astype(np.int32),\n", - " 0, ny - 1)\n", - " return ix, iy\n", - "\n", - "\n", - "def rasterize_closed_polyline_mask(\n", - " coords: np.ndarray,\n", - " extent: tuple[float, float, float, float],\n", - " nx: int,\n", - " ny: int,\n", - ") -> np.ndarray:\n", - " \"\"\"Rasterize a closed bead polyline into a 1-pixel-wide binary mask.\n", - "\n", - " Each consecutive bead pair (including the wrap-around from the last bead\n", - " back to the first) is drawn onto the grid using dense linear interpolation\n", - " along the segment. Duplicate pixels that would arise at segment junctions\n", - " are de-duplicated before writing.\n", - "\n", - " Parameters\n", - " ----------\n", - " coords : np.ndarray\n", - " Array of shape (N, 3) or (N, 2) containing bead positions in\n", - " nanometres. Only the first two columns (x, y) are used.\n", - " extent : tuple[float, float, float, float]\n", - " The physical bounding box (xmin, xmax, ymin, ymax) in nanometres.\n", - " nx : int\n", - " The number of pixels in the x-axis.\n", - " ny : int\n", - " The number of pixels in the y-axis.\n", - "\n", - " Returns\n", - " -------\n", - " np.ndarray\n", - " A binary mask of shape (ny, nx),\n", - " with True at every pixel where the polyline is present\n", - " and False everywhere else.\n", - "\n", - " Examples\n", - " --------\n", - " >>> mask = rasterize_closed_polyline_mask(coords, extent, nx=512, ny=512)\n", - " >>> print(mask.shape, mask.dtype)\n", - " (512, 512) bool\n", - "\n", - " \"\"\"\n", - "\n", - " coords = np.asarray(coords, dtype=np.float32)\n", - " ix, iy = nm_to_px(coords[:, :2], extent, nx, ny)\n", - " out = np.zeros((ny, nx), dtype=bool)\n", - " npts = len(ix)\n", - " for k in range(npts):\n", - " k2 = (k + 1) % npts\n", - " x0, y0 = int(ix[k]), int(iy[k])\n", - " x1, y1 = int(ix[k2]), int(iy[k2])\n", - " n_seg = int(max(abs(x1 - x0), abs(y1 - y0)) + 1)\n", - " if n_seg <= 1:\n", - " out[y0, x0] = True\n", - " continue\n", - " xs = np.linspace(x0, x1, n_seg).astype(np.int32)\n", - " ys = np.linspace(y0, y1, n_seg).astype(np.int32)\n", - " if xs.size > 1:\n", - " keep = np.ones(xs.shape[0], dtype=bool)\n", - " keep[1:] = (xs[1:] != xs[:-1]) | (ys[1:] != ys[:-1])\n", - " xs, ys = xs[keep], ys[keep]\n", - " out[ys, xs] = True\n", - " return out\n", - "\n", - "\n", - "def make_dna_mask_from_beads(\n", - " coords: np.ndarray,\n", - " extent: tuple[float, float, float, float],\n", - " nx: int,\n", - " ny: int,\n", - " dilate_px: int = 3,\n", - ") -> np.ndarray:\n", - " \"\"\"Build a binary DNA segmentation mask from bead coordinates.\n", - "\n", - " Rasterizes the closed bead polyline into a 1-pixel-wide line mask and\n", - " optionally dilates it by a disk of radius ``dilate_px`` pixels to produce a\n", - " mask wide enough for robust segmentation training.\n", - "\n", - " Parameters\n", - " ----------\n", - " coords : np.ndarray\n", - " Array of shape (N, 3) or (N,2) containing bead positions in nanometres.\n", - " Only the first two columns (x, y) are used.\n", - " extent : tuple[float, float, float, float]\n", - " The physical bounding box (xmin, xmax, ymin, ymax) in nanometres.\n", - " nx : int\n", - " The number of pixels in the x-axis.\n", - " ny : int\n", - " The number of pixels in the y-axis.\n", - " dilate_px : int, optional\n", - " Radius in pixels of the disk structuring element used to dilate\n", - " the rasterized line. Set to 0 to skip dilation. Defaults to 3.\n", - "\n", - " Returns\n", - " -------\n", - " np.ndarray\n", - " unit8 binary mask of shape (ny, nx)\n", - " with values 0 (background) or 1 (DNA).\n", - "\n", - " Examples\n", - " --------\n", - " >>> mask = make_dna_mask_from_beads(coords, extent, nx=512, ny=512,\n", - " dilate_px=DNA_MASK_DILATE_PX)\n", - " >>> print(mask.shape)\n", - " (512, 512)\n", - "\n", - " \"\"\"\n", - "\n", - " line = rasterize_closed_polyline_mask(coords, extent, nx, ny)\n", - " if dilate_px and dilate_px > 0:\n", - " fdp = float(dilate_px)\n", - " line = binary_dilation(line, structure=disk_footprint(fdp))\n", - " return line.astype(np.uint8)" - ] - }, - { - "cell_type": "markdown", - "id": "cell_md_08", - "metadata": { - "id": "cell_md_08" - }, - "source": [ - "## 9. Crossing Detection & Crossing Mask\n", - "\n", - "The functions in this cell decribe how crossings are detected. Crossings are detected using polyline intersections for different chain segments and the height information of the beads in those segments is used to assign top chain segment and bottom chain segment (also used for boosting crossings).\n", - "\n", - "We have set the masks for the crossings as chain weighted gaussians so that the machine learning models can have more information about the crossings and thus have better predictions." - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "id": "cell_code_08", - "metadata": { - "id": "cell_code_08" - }, - "outputs": [], - "source": [ - "def canon_axis(\n", - " u: np.ndarray) -> np.ndarray | None:\n", - " \"\"\"Normalize a 2-D vector and canonicalise its sign.\n", - "\n", - " Ensures that +v and -v are treated as the same axis direction by flipping\n", - " the sign so the first nonzero component is always positive. This makes axis\n", - " comparisons order-independent.\n", - "\n", - " Parameters\n", - " ----------\n", - " u: np.ndarray\n", - " A 2-D vector to normalize\n", - "\n", - " Returns\n", - " -------\n", - " np.ndarray | None\n", - " Unit vector with canonicalized sign, or None if u is zero or if input has\n", - " a norm below 1e-12.\n", - "\n", - " Examples\n", - " --------\n", - " >>> u = np.array([1.0, 2.0])\n", - " >>> v = canon_axis(u)\n", - " >>> print(v)\n", - " [0.4472136 0.8944272]\n", - "\n", - " \"\"\"\n", - "\n", - " u = np.asarray(u, dtype=float)\n", - " nrm = float(np.linalg.norm(u))\n", - " if nrm < 1e-12:\n", - " return None\n", - " u = u / nrm\n", - " if (u[0] < 0) or (abs(u[0]) < 1e-12 and u[1] < 0):\n", - " u = -u\n", - " return u\n", - "\n", - "\n", - "def find_polyline_crossings(\n", - " coords_xy: np.ndarray,\n", - " min_separation_beads: int = CROSS_MIN_SEP_BEADS,\n", - " merge_radius_nm: float = 0.5,\n", - ") -> list[dict]:\n", - " \"\"\"Detect all strand crossings of a closed ring polyline in XY.\n", - "\n", - " Performs a brute-force search over all segment pairs, skipping adjacent\n", - " segments, shared-vertex pairs, and pairs whose circular contour separation\n", - " is less than ``minimum_separation_beads``. Raw intersection hits that land\n", - " within ``merge_radius_nm`` of each other are clustered into a single\n", - " crossing, and duplicate chain-axis directions (within ~18°) are\n", - " deduplicated per cluster.\n", - "\n", - " Parameters\n", - " ----------\n", - " coords_xy : np.ndarray\n", - " Array of shape (N,2) containing the [x,y] bead positions in nanometers\n", - " min_separation_beads: int, optional\n", - " Minimum circular contour separation (in beads) required between 2\n", - " segments before their intersection is considered. Defaults to\n", - " CROSS_MIN_SEP_BEADS.\n", - " merge_radius_nm: float, optional\n", - " Maximum distance in nanometers between 2 raw intersections that are\n", - " clustered into a single crossing. Defaults to 0.5 nm.\n", - "\n", - " Returns\n", - " -------\n", - " list[dict]\n", - " Each dict represents one crossing and contains:\n", - " - ``pt_nm`` : np.ndarray, shape (2,) — position in nanometres.\n", - " - ``axes_nm`` : list of np.ndarray — deduplicated unit chain\n", - " direction vectors at the crossing.\n", - " - ``seg_i`` : int — index of the first segment.\n", - " - ``seg_j`` : int — index of the second segment.\n", - " - ``t`` : float — parametric position along segment i.\n", - " - ``u`` : float — parametric position along segment j.\n", - " - ``n_hits`` : int — number of raw hits merged into this cluster.\n", - "\n", - " Examples\n", - " --------\n", - " >>> crossings = find_polyline_crossings(coords[:,:2])\n", - " >>> print(type(crossings))\n", - " \n", - "\n", - " \"\"\"\n", - "\n", - " xy = np.asarray(coords_xy, dtype=float)\n", - " n = int(xy.shape[0])\n", - "\n", - " raw = []\n", - " for i in range(n):\n", - " i2 = (i + 1) % n\n", - " p1, p2 = xy[i], xy[i2]\n", - " for j in range(i + 1, n):\n", - " j2 = (j + 1) % n\n", - " if i == j or i2 == j or j2 == i:\n", - " continue\n", - " if _circ_sep(n, i, j) < int(min_separation_beads):\n", - " continue\n", - " q1, q2 = xy[j], xy[j2]\n", - " hit, pt, t, u = _seg_intersect_2d(p1, p2, q1, q2)\n", - " if not hit:\n", - " continue\n", - " ua = canon_axis(p2 - p1)\n", - " ub = canon_axis(q2 - q1)\n", - " if ua is None or ub is None:\n", - " continue\n", - " raw.append(dict(pt=np.array(pt, float),\n", - " axes=[ua, ub],\n", - " seg_i=int(i), seg_j=int(j),\n", - " t=float(t), u=float(u)))\n", - "\n", - " # Cluster nearby raw intersections\n", - " clusters = []\n", - " for r in raw:\n", - " pt = r[\"pt\"]\n", - " placed = False\n", - " for c in clusters:\n", - " fmc=float(merge_radius_nm)\n", - " if np.linalg.norm(pt - c[\"pt_sum\"] / c[\"n\"]) <= fmc:\n", - " c[\"pt_sum\"] += pt\n", - " c[\"n\"] += 1\n", - " c[\"axes\"].extend(r[\"axes\"])\n", - " c[\"items\"].append(r)\n", - " placed = True\n", - " break\n", - " if not placed:\n", - " clusters.append({\"pt_sum\": pt.copy(), \"n\": 1,\n", - " \"axes\": list(r[\"axes\"]), \"items\": [r]})\n", - "\n", - " out = []\n", - " for c in clusters:\n", - " pt_mean = c[\"pt_sum\"] / c[\"n\"]\n", - " axes = []\n", - " for uvec in c[\"axes\"]:\n", - " uvec = canon_axis(uvec)\n", - " if uvec is None:\n", - " continue\n", - " if any(abs(np.dot(uvec, v)) > 0.95 for v in axes): # ~18°\n", - " continue\n", - " axes.append(uvec)\n", - " rep = c[\"items\"][0]\n", - " out.append(dict(\n", - " pt_nm = np.asarray(pt_mean, dtype=np.float32),\n", - " axes_nm = [np.asarray(v, dtype=np.float32) for v in axes]\n", - " if axes else [np.array([1.0, 0.0], np.float32)],\n", - " seg_i = int(rep[\"seg_i\"]),\n", - " seg_j = int(rep[\"seg_j\"]),\n", - " t = float(rep[\"t\"]),\n", - " u = float(rep[\"u\"]),\n", - " n_hits = int(c[\"n\"]),\n", - " ))\n", - " return out\n", - "\n", - "\n", - "def add_crossing_patch(\n", - " mask: np.ndarray,\n", - " pt_px: tuple[float, float],\n", - " axes_px: list[np.ndarray],\n", - " sigma_center: float = 2.0,\n", - " chain_extent: float = 5.0,\n", - " sigma_perp: float = 1.8,\n", - " center_weight: float = 1.0,\n", - " chain_weight: float = 0.8,\n", - ") -> None:\n", - " \"\"\"Paint one crossing onto a float mask using a chain-weighted Gaussian.\n", - "\n", - " The patch is the sum of two components, composed with np.maximum so that\n", - " multiple crossings accumulate correctly without overwriting:\n", - "\n", - " - An isotropic Gaussian centred on the crossing point, scaled by\n", - " ``center_weight``.\n", - " - The per-axis maximum of anisotropic Gaussians aligned to each chain\n", - " direction (elongated along the chain, narrow across it), scaled by\n", - " ``chain_weight``.\n", - "\n", - " Parameters\n", - " ----------\n", - " mask: np.ndarray\n", - " Float32 array of shape (H,W) to paint onto.\n", - " pt_px: tuple[float, float]\n", - " (x,y) crossing point in pixel coordinates.\n", - " axes_px: list[np.ndarray]\n", - " Unit vectors giving chain directions at the crossing,\n", - " in pixel coordinates\n", - " sigma_center: float, optional\n", - " Parameter for standard deviation in pixels of the\n", - " isotropic center gaussian. Defaults to 2.0.\n", - " chain_extent: float, optional\n", - " Multiplier applied to \"sigma_center\" to set the\n", - " parallel standard deviation of the anisotropic chain gaussians.\n", - " Defaults to 5.0.\n", - " sigma_perp: float, optional\n", - " Parameter for standard deviation in pixels across each chain direction.\n", - " Defaults to 1.8\n", - " center_weight: float, optional\n", - " Amplitude of the isotropic center gaussian. Defaults to 1.0.\n", - " chain_weight: float, optional\n", - " Amplitude of the anisotropic chain gaussians. Defaults to 0.8.\n", - "\n", - " \"\"\"\n", - "\n", - " H, W = mask.shape\n", - " cx, cy = float(pt_px[0]), float(pt_px[1])\n", - " sigma_parallel = max(1e-6, float(chain_extent) * float(sigma_center))\n", - " R = int(np.ceil(3.0 * max(sigma_center, sigma_parallel, sigma_perp)))\n", - " x0 = max(0, int(np.floor(cx - R))); x1 = min(W-1, int(np.ceil(cx + R)))\n", - " y0 = max(0, int(np.floor(cy - R))); y1 = min(H-1, int(np.ceil(cy + R)))\n", - "\n", - " xs = np.arange(x0, x1+1, dtype=float)\n", - " ys = np.arange(y0, y1+1, dtype=float)\n", - " X, Y = np.meshgrid(xs, ys)\n", - " dx = X - cx; dy = Y - cy\n", - "\n", - " gc = np.exp(-0.5 * (dx*dx + dy*dy) / (sigma_center**2))\n", - "\n", - " g_chain = np.zeros_like(gc)\n", - " for v in axes_px:\n", - " vx, vy = float(v[0]), float(v[1])\n", - " u_par = dx*vx + dy*vy\n", - " u_perp = -dx*vy + dy*vx\n", - " g = np.exp(-0.5 * (u_par**2 / sigma_parallel**2\n", - " + u_perp**2 / sigma_perp**2))\n", - " g_chain = np.maximum(g_chain, g)\n", - "\n", - " patch = center_weight * gc + chain_weight * g_chain\n", - " mask[y0:y1+1, x0:x1+1] = np.maximum(mask[y0:y1+1, x0:x1+1], patch)\n", - "\n", - "\n", - "def make_crossing_mask(\n", - " coords: np.ndarray,\n", - " extent: tuple[float, float, float, float],\n", - " nx: int,\n", - " ny: int,\n", - " sigma_center_px: float = CROSS_SIGMA_CENTER_PX,\n", - " sigma_perp_px: float = CROSS_SIGMA_PERP_PX,\n", - " chain_extent: float = CROSS_CHAIN_EXTENT,\n", - " center_weight: float = CROSS_CENTER_WEIGHT,\n", - " chain_weight: float = CROSS_CHAIN_WEIGHT,\n", - " min_separation_beads: int = CROSS_MIN_SEP_BEADS,\n", - " crossings_precomputed: list[dict] | None = None,\n", - " merge_radius_nm: float = 0.5,\n", - ") -> tuple[np.ndarray, list[dict]]:\n", - " \"\"\"Build the crossing ground-truth mask (float32, normalised to [0, 1]).\n", - "\n", - " For each detected (or precomputed) crossing, paints a chain-weighted\n", - " Gaussian blob onto a float32 canvas using ``add_crossing_patch``.The final\n", - " mask is normalised to [0, 1].\n", - "\n", - " Passing ``crossings_precomputed`` is strongly recommended in the dataset\n", - " generation pipeline: reusing the same crossing list that was passed to the\n", - " AFM renderer guarantees that the mask and the image are perfectl\n", - " spatially aligned.\n", - "\n", - " Parameters\n", - " ----------\n", - " coords : np.ndarray\n", - " Array of shape (N,3) or (N,2) containing bead positions in nanometers.\n", - " Only the first two columns (x, y) are used.\n", - " Extent: tuple[float, float, float, float]\n", - " The physical bounding box (xmin, xmax, ymin, ymax) in nanometers.\n", - " nx: int\n", - " Number of pixels along the x-axis\n", - " ny: int\n", - " Number of pixels along the y-axis\n", - " sigma_center_px: float, optional\n", - " Parameter for standard deviation in pixels of the\n", - " isotropic center gaussian. Defaults to CROSS_SIGMA_CENTER_PX.\n", - " sigma_perp_px: float, optional\n", - " Parameter for standard deviation in pixels across the\n", - " chain direction at each crossing. Defaults to CROSS_SIGMA_PERP_PX.\n", - " chain_extent: float, optional\n", - " Multiplier on \"sigma_center_px\" that controls how far the\n", - " chain aligned gaussians extend along the strand.\n", - " Defaults to CROSS_CHAIN_EXTENT.\n", - " center_weight: float, optional\n", - " Amplitude of the isotropic center gaussian.\n", - " Defaults to CROSS_CENTER_WEIGHT.\n", - " chain_weight: float, optional\n", - " Amplitude of the anisotropic chain gaussians.\n", - " Defaults to CROSS_CHAIN_WEIGHT.\n", - " min_separation_beads: int, optional\n", - " Minimum circular contour separation (in beads)\n", - " required between 2 segments before their intersection is considered.\n", - " Defaults to CROSS_MIN_SEP_BEADS.\n", - " crossings_precomputed: list[dict] | None, optional\n", - " precomputed crossing list from \"find_polyline_crossings\"\n", - " or the AFM renderer. If None, crossings are detected automatically.\n", - " Defaults to None.\n", - " merge_radius_nm: float, optional\n", - " Maximum distance in nanometers between 2 raw\n", - " intersections that are clustered into a single crossing.\n", - " Defaults to 0.5 nm.\n", - "\n", - " Returns\n", - " -------\n", - " crossing_mask: np.ndarray\n", - " Float32 array of shape (ny, nx) with values in [0, 1].\n", - " crossings: list[dict]\n", - " Each dict represents one crossing\n", - "\n", - " Examples\n", - " --------\n", - " >>> crossing_mask, crossings = make_crossing_mask(coords,\n", - " extent, nx=512, ny=512, crossings_precomputed=precomputed_crossings)\n", - " >>> print(crossing_mask.shape, len(crossings))\n", - " (512, 512) 4\n", - "\n", - " \"\"\"\n", - "\n", - " coords = np.asarray(coords, dtype=np.float32)\n", - " xy_nm = coords[:, :2].astype(float)\n", - "\n", - " if crossings_precomputed is None:\n", - " crossings = find_polyline_crossings(\n", - " xy_nm,\n", - " min_separation_beads=min_separation_beads,\n", - " merge_radius_nm=float(merge_radius_nm),\n", - " )\n", - " else:\n", - " crossings = crossings_precomputed\n", - "\n", - " xmin, xmax, ymin, ymax = extent\n", - " sx = (nx - 1) / (xmax - xmin)\n", - " sy = (ny - 1) / (ymax - ymin)\n", - "\n", - " mask = np.zeros((ny, nx), dtype=np.float32)\n", - "\n", - " for c in crossings:\n", - " x_nm, y_nm = c[\"pt_nm\"]\n", - " px = (x_nm - xmin) * sx\n", - " py = (y_nm - ymin) * sy\n", - "\n", - " axes_px = []\n", - " for v in c[\"axes_nm\"]:\n", - " vx_px = v[0] * sx; vy_px = v[1] * sy\n", - " nrm = float(np.hypot(vx_px, vy_px))\n", - " if nrm < 1e-12:\n", - " continue\n", - " axes_px.append(np.array([vx_px/nrm, vy_px/nrm], dtype=float))\n", - " if not axes_px:\n", - " axes_px = [np.array([1.0, 0.0], dtype=float)]\n", - "\n", - " add_crossing_patch(\n", - " mask,\n", - " pt_px=(px, py),\n", - " axes_px=axes_px,\n", - " sigma_center=float(sigma_center_px),\n", - " chain_extent=float(chain_extent),\n", - " sigma_perp=float(sigma_perp_px),\n", - " center_weight=float(center_weight),\n", - " chain_weight=float(chain_weight),\n", - " )\n", - "\n", - " m = float(mask.max())\n", - " if m > 1e-12:\n", - " mask /= m\n", - " return mask.astype(np.float32), crossings" - ] - }, - { - "cell_type": "markdown", - "id": "cell_md_09", - "metadata": { - "id": "cell_md_09" - }, - "source": [ - "## 10. Decoy Chain Functions\n", - "\n", - "real AFM images often contain small chain segments that are not part of the main chain and thus constitute the noise in that sample, but since those segments are broken off DNA, they cannot be neatly integrated into the noise model.\n", - "Therefore, we offer the possibility of addition of small DNA chains to every every sample in the dataset where ``add_decoy = True`` which would then contain a small 2–4 bead \"decoy\" fragment placed in a corner of the image.\n", - "\n", - "The decoy appears in the AFM image but is **excluded** from both\n", - "ground-truth masks, training the model to ignore isolated unconnected fragments." - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "id": "cell_code_09", - "metadata": { - "id": "cell_code_09" - }, - "outputs": [], - "source": [ - "def make_decoy_chain(\n", - " seed: int,\n", - " n_beads_range: tuple[int, int] = (2, 4),\n", - " bond_length: float = BOND_LENGTH,\n", - ") -> np.ndarray:\n", - " \"\"\"Generate a small (2–4 bead) slightly curved chain without MD relaxation.\n", - "\n", - " This function is used to generate a small decoy chain segment with the\n", - " number of beads given by ``n_beads_range``.\n", - "\n", - " Parameters\n", - " ----------\n", - " seed: int\n", - " Random seed for number of beads within range, ``n_beads_range``.\n", - " n_beads_range: tuple[int, int], optional\n", - " Range of number of beads to generate the decoy. Defaults to (2,4)\n", - " bond_length: float, optional\n", - " Bond length in nanometers. Defaults to BOND_LENGTH.\n", - "\n", - " Returns\n", - " -------\n", - " coords: np.ndarray\n", - " Array of shape (N,3) containing bead positions in nanometers.\n", - "\n", - " Examples\n", - " --------\n", - " >>> coords = make_decoy_chain(seed=42)\n", - " >>> print(coords.shape)\n", - " (3, 3)\n", - "\n", - " \"\"\"\n", - "\n", - " rng = np.random.default_rng(int(seed))\n", - " n_b = rng.integers(n_beads_range[0], n_beads_range[1] + 1)\n", - " coords = np.zeros((n_b, 3), dtype=np.float32)\n", - " angle = rng.uniform(0, 2 * np.pi)\n", - " dirn = np.array([np.cos(angle), np.sin(angle), 0.0], dtype=np.float32)\n", - "\n", - " for i in range(1, n_b):\n", - " da = rng.normal(0, 0.3)\n", - " c, s = np.cos(da), np.sin(da)\n", - " R = np.array([[c, -s, 0], [s, c, 0], [0, 0, 1]], dtype=np.float32)\n", - " dirn = R @ dirn\n", - " dirn = dirn / np.linalg.norm(dirn)\n", - " coords[i] = coords[i-1] + bond_length * dirn\n", - "\n", - " coords[:, 2] = rng.uniform(2.5, 4.0, n_b)\n", - " return coords\n", - "\n", - "\n", - "def place_decoy_in_corner(\n", - " decoy_coords: np.ndarray,\n", - " global_extent: tuple[float, float, float, float],\n", - " corner_margin_nm: float = 2.0,\n", - " seed: int | None = None,\n", - ") -> np.ndarray:\n", - " \"\"\"Translate decoy_coords so its centroid lands in a random corner.\n", - "\n", - " This function takes the coordinates of the decoy and places it at a\n", - " distance of corner_margin_nm away from one of the corners of the image.\n", - "\n", - " Parameters\n", - " ----------\n", - " decoy_coords: np.ndarray\n", - " Array of shape (N,3) containing bead positions in nanometers.\n", - " global_extent: tuple[float float float float]\n", - " The physical bounding box (xmin, xmax, ymin, ymax) in nanometers.\n", - " corner_margin_nm: float, optional\n", - " Distance in nanometers to place the decoy inside the frame.\n", - " Defaults to 2.0.\n", - " seed: int | None, optional\n", - " Random seed for corner selection. Defaults to None.\n", - "\n", - " Returns\n", - " -------\n", - " decoy_coords: np.ndarray\n", - "\n", - " Examples\n", - " --------\n", - " >>> decoy_coords = place_decoy_in_corner(decoy_coords, global_extent)\n", - " >>> print(decoy_coords.shape)\n", - " (3, 3)\n", - "\n", - " \"\"\"\n", - "\n", - " if seed is None:\n", - " seed = int(np.sum(decoy_coords))\n", - " rng = np.random.default_rng(int(seed))\n", - " xmin, xmax, ymin, ymax = global_extent\n", - " corner = rng.integers(0, 4)\n", - " targets = [\n", - " (xmin + corner_margin_nm, ymax - corner_margin_nm), # top-left\n", - " (xmax - corner_margin_nm, ymax - corner_margin_nm), # top-right\n", - " (xmin + corner_margin_nm, ymin + corner_margin_nm), # bottom-left\n", - " (xmax - corner_margin_nm, ymin + corner_margin_nm), # bottom-right\n", - " ]\n", - " tx, ty = targets[corner]\n", - " centroid = decoy_coords.mean(axis=0)\n", - " offset = np.array([tx, ty, 0.0]) - centroid\n", - " return decoy_coords + offset" - ] - }, - { - "cell_type": "markdown", - "id": "cell_md_10", - "metadata": { - "id": "cell_md_10" - }, - "source": [ - "## 11. Chain Generation Pipeline\n", - "\n", - "Now, we are finally ready to generate on sample in our dataset. The following functions are used for building the final image and masks:\n", - "- `generate_chain_with_beads` with `n_beads` defaulting to `N_BEADS`\n", - "- `generate_one_sample_multilength` generates the image and mask (this is what iterates to produce the dataset)\n", - "- `random_transform_noise_texture` applies a per-sample random affine transform to the noise texture for variety (in case of blank .spm files)\n", - "- Noise injection uses `blank.spm` when available and the PSD model fallback otherwise\n" - ] - }, - { - "cell_type": "code", - "execution_count": 59, - "id": "cell_code_10", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "cell_code_10", - "outputId": "b8656359-509b-49c6-e046-61abba117519" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Chosen block: 'Z offset: V [Sens. DeformationSens] (0.00000000093132 V/LSB) 0.01733094 V' 512x512 bpp=4 decode= dict[str, Any]:\n", - " \"\"\"Build a tangled ring with n_beads and run MD relaxation if needed.\n", - "\n", - " This function creates an initial ring polymer with a specified number of\n", - " beads, optionally relaxes it using molecular dynamics, and extracts the\n", - " final bead coordinates. Self-crossings are then detected from the final\n", - " 2D projection of the chain.\n", - " Optionally, a decoy chain fragment can also be generated and placed near\n", - " one corner of the main chain bounding box.\n", - "\n", - " Parameters\n", - " ----------\n", - " seed: int\n", - " Random seed for initial ring creation.\n", - " n_beads: int\n", - " Number of beads in the initial ring. Defaults to N_BEADS.\n", - " add_decoy: bool\n", - " Whether to add a corner-placed decoy fragment. Defaults to False.\n", - "\n", - " Returns\n", - " -------\n", - " A dict containing the following keys:\n", - " - ``\"seed\"`` : int\n", - " The normalized integer seed.\n", - " - ``\"n_beads\"`` : int\n", - " Number of beads in the generated chain.\n", - " - ``\"coords\"`` : np.ndarray\n", - " Final bead coordinates with shape ``(N, 3)`` and dtype\n", - " ``np.float32``.\n", - " - ``\"crossings\"`` : list\n", - " Detected self-crossings in the 2D projected chain.\n", - " - ``\"decoy_coords\"`` : np.ndarray or None\n", - " Coordinates of the optional decoy fragment, or ``None`` if no\n", - " decoy was added.\n", - "\n", - " Examples\n", - " --------\n", - " >>> chain = generate_chain_with_beads(seed=42, n_beads=10)\n", - " >>> chain[\"seed\"]\n", - " 42\n", - " >>> chain[\"n_beads\"]\n", - " 10\n", - " >>> chain[\"coords\"].shape\n", - " (10, 3)\n", - "\n", - " \"\"\"\n", - "\n", - " seed = int(seed)\n", - " n_beads = int(n_beads)\n", - "\n", - " if USE_MD:\n", - " coords0 = make_tangled_ring_initial(\n", - " seed,\n", - " n_beads=n_beads,\n", - " bond_length=BOND_LENGTH,\n", - " persistence_bonds=PERSISTENCE_BONDS,\n", - " base_z=BASE_Z,\n", - " )\n", - " frames = run_md_relaxation(coords0, seed=seed,\n", - " n_frames=N_FRAMES,\n", - " steps_per_frame=STEPS_PER_FRAME)\n", - " else:\n", - " frames = make_ring_2d_persistent_initial(\n", - " seed,\n", - " n_beads=n_beads,\n", - " bond_length=BOND_LENGTH,\n", - " persistence_bonds=PERSISTENCE_BONDS,\n", - " angle_stiffness_mult=ANGLE_STIFNESS_MULT,\n", - " )\n", - "\n", - " last_coords = frames[-1].astype(np.float32)\n", - "\n", - " crossings = find_polyline_crossings(\n", - " last_coords[:, :2],\n", - " min_separation_beads=CROSS_MIN_SEP_BEADS,\n", - " merge_radius_nm=0.5,\n", - " )\n", - "\n", - " decoy_coords = None\n", - " if add_decoy:\n", - " xmin, xmax = last_coords[:, 0].min(), last_coords[:, 0].max()\n", - " ymin, ymax = last_coords[:, 1].min(), last_coords[:, 1].max()\n", - " decoy_raw = make_decoy_chain(seed + 9999)\n", - " decoy_coords = place_decoy_in_corner(\n", - " decoy_raw, (xmin, xmax, ymin, ymax),\n", - " corner_margin_nm=15.0, seed=seed)\n", - "\n", - " return dict(seed=seed, n_beads=n_beads,\n", - " coords=last_coords, crossings=crossings,\n", - " decoy_coords=decoy_coords)\n", - "\n", - "\n", - "def render_chain_and_masks(\n", - " chain: dict,\n", - " noise_source: str = \"none\",\n", - " noise_asset: dict | np.ndarray | None = None,\n", - ") -> dict[str, Any]:\n", - " \"\"\"Render AFM image + DNA mask + crossing mask for a chain dict.\n", - "\n", - " This function renders a high-resolution AFM image from a chain sample,\n", - " optionally composites a decoy fragment into the image, adds background\n", - " noise, and generates corresponding DNA and crossing masks.\n", - " The AFM image is first rendered on an internal physical grid determined\n", - " from the chain extent and the target pixel size. The image and masks are\n", - " then resized to the final network resolution.\n", - " Decoy fragments, when present, are composited into the AFM image using\n", - " maximum-intensity blending, but are deliberately excluded from both the\n", - " DNA mask and crossing mask.\n", - "\n", - " Parameters\n", - " ----------\n", - " chain: dict\n", - " A dict containing the following keys:\n", - " -``\"seed\"``\n", - " -``\"coords\"``\n", - " -``\"crossings\"``.\n", - " The optional key\n", - " ``\"decoy_coords\"`` may also be present\n", - " noise_source: str\n", - " Noise generation source passed to `sample_noise_image`.\n", - " noise_asset: dict | np.ndarray | None\n", - " Noise asset passed to `sample_noise_image`\n", - "\n", - " Returns\n", - " -------\n", - " A dict containing the following keys:\n", - " - ``\"seed\"`` : int\n", - " Random seed associated with the sample.\n", - " - ``\"afm_img\"`` : np.ndarray\n", - " Final AFM image with shape ``(NY, NX)`` and dtype\n", - " ``np.float32``.\n", - " - ``\"dna_mask\"`` : np.ndarray\n", - " Final binary DNA mask with shape ``(NY, NX)`` and dtype\n", - " ``np.uint8``.\n", - " - ``\"cross_mask\"`` : np.ndarray\n", - " Final crossing mask with shape ``(NY, NX)`` and dtype\n", - " ``np.float32``.\n", - " - ``\"extent\"`` : np.ndarray\n", - " Physical image extent as ``(xmin, xmax, ymin, ymax)`` with dtype\n", - " ``np.float32``.\n", - " - ``\"n_crossings\"`` : int\n", - " Number of crossing regions included in the crossing mask.\n", - " - ``\"decoy_coords\"`` : np.ndarray or None\n", - " Final decoy coordinates, or ``None`` if no decoy was used.\n", - "\n", - " Examples\n", - " --------\n", - " >>> sample = generate_chain_with_beads(seed=1)\n", - " >>> rendered = render_chain_and_masks(sample)\n", - " >>> rendered[\"afm_img\"].shape\n", - " (NY, NX)\n", - " >>> rendered[\"dna_mask\"].dtype\n", - " dtype('uint8')\n", - "\n", - " \"\"\"\n", - "\n", - " seed = int(chain[\"seed\"])\n", - " coords = chain[\"coords\"]\n", - " crossings = chain[\"crossings\"]\n", - " decoy_coords = chain.get(\"decoy_coords\", None)\n", - "\n", - " padding = 10.0\n", - " xmin = coords[:, 0].min() - padding\n", - " xmax = coords[:, 0].max() + padding\n", - " ymin = coords[:, 1].min() - padding\n", - " ymax = coords[:, 1].max() + padding\n", - " global_extent = (xmin, xmax, ymin, ymax)\n", - "\n", - " # internal render grid is determined from extent and nm_per_px\n", - " nx_phys, ny_phys, _ = compute_internal_render_grid(\n", - " global_extent, AFM_KW[\"target_nm_per_px\"]\n", - " )\n", - " afm_kw_phys = {**AFM_KW, \"nx\": nx_phys, \"ny\": ny_phys}\n", - "\n", - " afm_img_hr, dbg = create_z_based_afm(\n", - " coords, grain_seed=seed,\n", - " crossings_precomputed=crossings,\n", - " extent=global_extent,\n", - " **afm_kw_phys\n", - " )\n", - "\n", - " if decoy_coords is not None:\n", - " decoy_coords = place_decoy_in_corner(\n", - " decoy_coords, global_extent,\n", - " corner_margin_nm=8.0, seed=seed)\n", - " decoy_kw = {**afm_kw_phys,\n", - " \"apply_edge_taper\": False,\n", - " \"enable_crossing_boost\": False,\n", - " \"add_center_ridge\": False}\n", - " decoy_afm_hr, _ = create_z_based_afm(\n", - " decoy_coords, extent=global_extent, **decoy_kw)\n", - " afm_img_hr = np.maximum(afm_img_hr, decoy_afm_hr)\n", - "\n", - " actual_extent = dbg[\"extent\"]\n", - "\n", - " noise_img = sample_noise_image(\n", - " noise_source=noise_source,\n", - " noise_asset=noise_asset,\n", - " seed=seed,\n", - " out_shape=afm_img_hr.shape,\n", - " target_rms_nm=TARGET_NOISE_RMS_NM,\n", - " )\n", - " if noise_img is not None:\n", - " afm_img_hr = np.clip((afm_img_hr + noise_img).astype(np.float32),\n", - " 0, AFM_KW[\"max_height_nm\"])\n", - "\n", - " dna_mask_hr = make_dna_mask_from_beads(\n", - " coords, actual_extent, nx_phys, ny_phys, dilate_px=DNA_MASK_DILATE_PX)\n", - "\n", - " cross_mask_hr, crossings_out = make_crossing_mask(\n", - " coords, actual_extent, nx_phys, ny_phys,\n", - " sigma_center_px=CROSS_SIGMA_CENTER_PX,\n", - " sigma_perp_px=CROSS_SIGMA_PERP_PX,\n", - " chain_extent=CROSS_CHAIN_EXTENT,\n", - " center_weight=CROSS_CENTER_WEIGHT,\n", - " chain_weight=CROSS_CHAIN_WEIGHT,\n", - " min_separation_beads=CROSS_MIN_SEP_BEADS,\n", - " crossings_precomputed=crossings,\n", - " merge_radius_nm=0.5,\n", - " )\n", - "\n", - " if CROSS_CLIP_TO_DNA_MASK:\n", - " cross_mask_hr = cross_mask_hr * dna_mask_hr.astype(np.float32)\n", - "\n", - " #Logic for maintaining user defined resolution\n", - " afm_img = resize_image_to_shape(afm_img_hr.astype(np.float32),\n", - " (NY, NX), order=1).astype(np.float32)\n", - " dna_mask = (resize_image_to_shape(dna_mask_hr.astype(np.float32),\n", - " (NY, NX), order=0)>0.5).astype(np.uint8)\n", - " cross_mask = resize_image_to_shape(cross_mask_hr.astype(np.float32),\n", - " (NY, NX), order=1).astype(np.float32)\n", - "\n", - " return dict(\n", - " seed=seed,\n", - " afm_img=afm_img.astype(np.float32),\n", - " dna_mask=dna_mask.astype(np.uint8),\n", - " cross_mask=cross_mask.astype(np.float32),\n", - " extent=np.array(actual_extent, dtype=np.float32),\n", - " n_crossings=int(len(crossings_out)),\n", - " decoy_coords=decoy_coords,\n", - " )\n", - "\n", - "\n", - "def generate_one_sample_multilength(\n", - " seed: int,\n", - " n_beads: int,\n", - " noise_source: str = \"none\",\n", - " noise_asset: dict | np.ndarray | None = None,\n", - " add_decoy: bool = False,\n", - ") -> dict[str, Any]:\n", - " \"\"\"Generate one complete sample at a specified bead count.\n", - "\n", - " This function generates a single chain realization with the requested\n", - " number of beads, renders the corresponding AFM image and supervision masks,\n", - " and appends the bead count to the returned sample dictionary.\n", - "\n", - " Noise can optionally be injected during rendering using either a blank\n", - " SPM-derived texture or a PSD-based synthetic noise model, depending on\n", - " the provided noise configuration.\n", - "\n", - " Parameters\n", - " ----------\n", - " seed: int\n", - " Random seed for initial ring creation.\n", - " n_beads: int\n", - " Number of beads in the initial ring.\n", - " noise_source: str, optional\n", - " Noise generation source passed to `render_chain_and_masks`.\n", - " Defaults to \"none\".\n", - " noise_asset: dict | np.ndarray | None, optional\n", - " Noise asset passed to `render_chain_and_masks`. Defaults to `None`.\n", - " add_decoy: bool, optional\n", - " Whether to add a corner-placed decoy fragment. Defaults to `False`.\n", - "\n", - " Returns\n", - " -------\n", - " dict[str, Any]\n", - " Dictionary containing the rendered sample, including AFM image,\n", - " DNA mask, crossing mask, physical extent, crossing count, optional\n", - " decoy coordinates, and the bead count under ``\"n_beads\"``.\n", - "\n", - " Notes\n", - " -----\n", - " This function prints which noise model is being used for the noise\n", - " injection and if no noise model has been provided then\n", - " it prints a statement that reflects that noise injection has been disabled.\n", - "\n", - " Examples\n", - " --------\n", - " >>> sample = generate_one_sample_multilength(seed=1, n_beads=300)\n", - " >>> sample[\"n_beads\"]\n", - " 300\n", - "\n", - " >>> sample[\"afm_img\"].shape\n", - " (NY, NX)\n", - "\n", - " \"\"\"\n", - "\n", - " chain = generate_chain_with_beads(seed, n_beads, add_decoy=add_decoy)\n", - "\n", - " s = render_chain_and_masks(\n", - " chain,\n", - " noise_source=noise_source,\n", - " noise_asset=noise_asset,\n", - " )\n", - " s[\"n_beads\"] = int(n_beads)\n", - " return s\n", - "\n", - "\n", - "# ── Load noise asset once; prefer blank.spm, fall back to PSD model ──────────\n", - "noise_source = \"none\"\n", - "noise_asset = None\n", - "noise_diag = {\"source\": \"none\"}\n", - "\n", - "if USE_BLANK_SPM_NOISE:\n", - " blank_path = str(BLANK_SPM_PATH) if BLANK_SPM_PATH else \"\"\n", - " if blank_path and os.path.isfile(blank_path):\n", - " try:\n", - " noise_rms_nm, noise_asset, noise_diag = load_blank_spm_noise(\n", - " blank_path,\n", - " target_rms_nm=TARGET_NOISE_RMS_NM,\n", - " verbose=True,\n", - " )\n", - " noise_source = \"blank_spm\"\n", - " print(f\"Loaded blank .spm noise texture\"\n", - " f\" RMS ≈ {noise_rms_nm:.3f} nm\")\n", - " except Exception as e:\n", - " print(\"blank .spm noise failed; trying PSD fallback. Error:\", e)\n", - " else:\n", - " print(\"No blank .spm file found; trying PSD fallback noise model.\")\n", - "\n", - "if noise_source == \"none\" and USE_PSD_NOISE_FALLBACK:\n", - " try:\n", - " noise_asset = load_model(MODEL_PATH)\n", - " noise_source = \"psd_model\"\n", - " noise_diag = {\n", - " \"source\": \"psd_model\",\n", - " \"model_path\": str(MODEL_PATH),\n", - " \"method\": PSD_NOISE_METHOD,\n", - " \"target_rms_nm\": float(TARGET_NOISE_RMS_NM),\n", - " }\n", - " print(f\"Loaded PSD fallback noise model from: {MODEL_PATH}\")\n", - " except Exception as e:\n", - " print(\"PSD fallback noise model failed;\"\n", - " \"proceeding without noise. Error:\", e)\n", - " noise_asset = None\n", - "\n", - "if noise_source == \"none\":\n", - " print(\"Noise injection disabled.\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "cell_md_11", - "metadata": { - "id": "cell_md_11" - }, - "source": [ - "## 12. Sanity Check\n", - "\n", - "It is always a good idea to check if the pipeline is working correctly and producing the inteded resutls and so we have added a sanity check that can be performed before starting the generation of the entire dataset.\n", - "Here we render one sample per bead count for the bead counts provided in the global variables and by default we have set `add_decoy=True` here.\n", - "\n", - "This check displays the AFM image, DNA mask, and crossing mask side-by-side.\n", - "We also print the extent / decoy-placement diagnostics for verification and adjustment." - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "id": "cell_code_11", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "cell_code_11", - "outputId": "f6277616-5d72-491c-ed9e-12b8268f0b7e" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " CUDA unavailable: There is no registered Platform called \"CUDA\"\n", - "Using OpenCL platform.\n", - " CUDA unavailable: There is no registered Platform called \"CUDA\"\n", - "Using OpenCL platform.\n", - " CUDA unavailable: There is no registered Platform called \"CUDA\"\n", - "Using OpenCL platform.\n", - " CUDA unavailable: There is no registered Platform called \"CUDA\"\n", - "Using OpenCL platform.\n", - "\n", - "==================== SAMPLE 1 (Seed: 1, 70 beads) ====================\n", - "Image window (nm): X=[-16.7, 16.5], Y=[-16.4, 16.1]\n", - "Decoy XY bounds (nm): X=[8.2, 8.8], Y=[7.7, 8.5]\n", - "Decoy Z range (nm): -0.03 – 0.03\n", - "Decoy inside extent.\n", - " Decoy height ≈ 0\n", - "\n", - "==================== SAMPLE 2 (Seed: 2, 80 beads) ====================\n", - "Image window (nm): X=[-20.8, 19.6], Y=[-20.7, 20.9]\n", - "Decoy XY bounds (nm): X=[11.4, 11.9], Y=[-13.6, -11.7]\n", - "Decoy Z range (nm): -0.26 – 0.15\n", - "Decoy inside extent.\n", - "\n", - "==================== SAMPLE 3 (Seed: 3, 90 beads) ====================\n", - "Image window (nm): X=[-27.8, 25.9], Y=[-14.4, 14.1]\n", - "Decoy XY bounds (nm): X=[17.6, 18.2], Y=[-7.8, -4.9]\n", - "Decoy Z range (nm): -0.39 – 0.44\n", - "Decoy inside extent.\n", - "\n", - "==================== SAMPLE 4 (Seed: 4, 100 beads) ====================\n", - "Image window (nm): X=[-20.9, 20.9], Y=[-24.3, 21.5]\n", - "Decoy XY bounds (nm): X=[-13.0, -12.7], Y=[-16.8, -15.8]\n", - "Decoy Z range (nm): -0.24 – 0.24\n", - "Decoy inside extent.\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "bead_counts = list(BEAD_COUNTS)\n", - "seeds = [int(BASE_SEED + k) for k in range(len(bead_counts))]\n", - "\n", - "samples = [\n", - " generate_one_sample_multilength(\n", - " seeds[i], n_beads=bead_counts[i],\n", - " noise_source=noise_source, noise_asset=noise_asset, add_decoy=True\n", - " )\n", - " for i in range(len(bead_counts))\n", - "]\n", - "#---------Plotting-------------------------------------------------------------\n", - "\n", - "fig, axes = plt.subplots(len(samples), 3, figsize=(16, 5 * len(samples)))\n", - "\n", - "for r, s in enumerate(samples):\n", - " extent = s[\"extent\"]\n", - " img = s[\"afm_img\"]\n", - "\n", - " print(f\"\\n{'='*20} SAMPLE {r+1} (Seed: {s['seed']}, \"\n", - " f\"{s['n_beads']} beads) {'='*20}\")\n", - " print(f\"Image window (nm): X=[{extent[0]:.1f}, {extent[1]:.1f}], \"\n", - " f\"Y=[{extent[2]:.1f}, {extent[3]:.1f}]\")\n", - "\n", - " if s.get(\"decoy_coords\") is not None:\n", - " d = s[\"decoy_coords\"]\n", - " print(f\"Decoy XY bounds (nm): \"\n", - " f\"X=[{d[:,0].min():.1f}, {d[:,0].max():.1f}], \"\n", - " f\"Y=[{d[:,1].min():.1f}, {d[:,1].max():.1f}]\")\n", - " print(f\"Decoy Z range (nm): {d[:,2].min():.2f} – {d[:,2].max():.2f}\")\n", - " oob = (d[:,0].min() < extent[0] or d[:,0].max() > extent[1] or\n", - " d[:,1].min() < extent[2] or d[:,1].max() > extent[3])\n", - " print(\" Decoy out-of-bounds!\" if oob else \"Decoy inside extent.\")\n", - " if d[:,2].max() < 0.1:\n", - " print(\" Decoy height ≈ 0\")\n", - "\n", - " ax1, ax2, ax3 = axes[r]\n", - " ext_list = list(extent)\n", - "\n", - " ax1.imshow(img, cmap=\"afmhot\", origin=\"lower\", extent=ext_list)\n", - " ax1.set_title(f\"AFM image\\n(seed {s['seed']}, {s['n_beads']} beads)\")\n", - " ax1.axis(\"off\")\n", - "\n", - " ax2.imshow(s[\"dna_mask\"], cmap=\"gray\", origin=\"lower\", extent=ext_list)\n", - " ax2.set_title(\"DNA mask (decoy excluded)\")\n", - " ax2.axis(\"off\")\n", - "\n", - " ax3.imshow(s[\"cross_mask\"], cmap=\"magma\", origin=\"lower\", extent=ext_list)\n", - " ax3.set_title(f\"Crossing mask (n={s['n_crossings']})\")\n", - " ax3.axis(\"off\")\n", - "\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "3YoKkN3e5dIo", - "metadata": { - "id": "3YoKkN3e5dIo" - }, - "source": [ - "## 13. Benchmarking\n", - "\n", - "We also provide the option to benchmark the performance of the pipeline and to see estimates on how long it might take to generate the required amount of samples. This can be very useful to compare which system might be optimal for production of the dataset and how GPU acceleration can be used to improve the time needed for dataset generation." - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "WLAYkyIQlhuX", - "metadata": { - "id": "WLAYkyIQlhuX" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "==============================================================\n", - " SYSTEM PROFILE\n", - "==============================================================\n", - " OS : Windows 10\n", - " CPU (logical) : 24 cores\n", - " RAM available : 39.8 GB\n", - " OpenMM Platforms: ['Reference', 'CPU', 'OpenCL']\n", - " Active Platform : OpenCL\n", - " Mode : MD (OpenMM)\n", - "\n", - "==============================================================\n", - " RUNNING BENCHMARK\n", - "==============================================================\n", - " CUDA unavailable: There is no registered Platform called \"CUDA\"\n", - "Using OpenCL platform.\n", - " Rep 1/3: 5.47s\n", - " CUDA unavailable: There is no registered Platform called \"CUDA\"\n", - "Using OpenCL platform.\n", - " Rep 2/3: 5.47s\n", - " CUDA unavailable: There is no registered Platform called \"CUDA\"\n", - "Using OpenCL platform.\n", - " Rep 3/3: 5.42s\n", - "==============================================================\n", - " Median Wall Time: 5.47 s\n", - " Mean Wall Time : 5.45 s\n", - " Peak RAM (RSS) : 431.1 MB\n", - " Projected Total : 0.4 hours for 280 samples\n", - "==============================================================\n" - ] - } - ], - "source": [ - "import time\n", - "import tracemalloc\n", - "import os\n", - "import platform\n", - "import psutil\n", - "import threading\n", - "import statistics\n", - "\n", - "class _PeakMemTracker:\n", - " \"\"\"Track peak resident memory usage in a background thread.\n", - "\n", - " This helper periodically samples the current process RSS and stores the\n", - " largest value observed during the tracked interval.\n", - "\n", - " Attributes\n", - " ----------\n", - " peak_mb : float\n", - " Peak resident set size observed during tracking, in megabytes.\n", - " \"\"\"\n", - "\n", - " def __init__(self, poll_interval_s: float = 0.05) -> None:\n", - " \"\"\"Initialize the memory tracker.\n", - "\n", - " Parameters\n", - " ----------\n", - " poll_interval_s : float, optional\n", - " Sampling interval in seconds, by default ``0.05``.\n", - " \"\"\"\n", - " self._process = psutil.Process(os.getpid())\n", - " self._poll_interval_s = float(poll_interval_s)\n", - " self._stop_event = threading.Event()\n", - " self._thread: threading.Thread | None = None\n", - " self.peak_mb = 0.0\n", - "\n", - " def _run(self) -> None:\n", - " \"\"\"Continuously sample RSS until tracking is stopped.\"\"\"\n", - " while not self._stop_event.is_set():\n", - " try:\n", - " rss_mb = self._process.memory_info().rss / 1e6\n", - " if rss_mb > self.peak_mb:\n", - " self.peak_mb = rss_mb\n", - " except Exception:\n", - " pass\n", - "\n", - " self._stop_event.wait(self._poll_interval_s)\n", - "\n", - " def start(self) -> None:\n", - " \"\"\"Start background memory tracking.\"\"\"\n", - " self._stop_event.clear()\n", - " self._thread = threading.Thread(target=self._run, daemon=True)\n", - " self._thread.start()\n", - "\n", - " def stop(self) -> None:\n", - " \"\"\"Stop background memory tracking.\"\"\"\n", - " self._stop_event.set()\n", - " if self._thread is not None:\n", - " self._thread.join()\n", - "\n", - "\n", - "def _bench_stages(\n", - " seed: int,\n", - " n_beads: int\n", - ") -> dict[str, float]:\n", - " \"\"\"Benchmark the major stages of one sample-generation pipeline run.\n", - "\n", - " Parameters\n", - " ----------\n", - " seed : int\n", - " Random seed for the benchmarked sample.\n", - " n_beads : int\n", - " Number of beads in the benchmarked chain.\n", - "\n", - " Returns\n", - " -------\n", - " dict[str, float]\n", - " Stage timings in seconds. Keys are:\n", - " ``\"1_chain_init\"``, ``\"2_md_relax\"``, ``\"3_crossing_detect\"``,\n", - " and ``\"4_afm_render_masks\"``.\n", - "\n", - " \"\"\"\n", - "\n", - " seed = int(seed)\n", - " n_beads = int(n_beads)\n", - "\n", - " timings: dict[str, float] = {}\n", - " t0 = time.perf_counter()\n", - "\n", - " if USE_MD:\n", - " coords0 = make_tangled_ring_initial(seed, n_beads=n_beads)\n", - " timings[\"1_chain_init\"] = time.perf_counter() - t0\n", - "\n", - " t0 = time.perf_counter()\n", - " frames = run_md_relaxation(\n", - " coords0,\n", - " seed=seed,\n", - " n_frames=N_FRAMES,\n", - " steps_per_frame=STEPS_PER_FRAME,\n", - " )\n", - " timings[\"2_md_relax\"] = time.perf_counter() - t0\n", - " else:\n", - " timings[\"1_chain_init\"] = 0.0\n", - "\n", - " t0 = time.perf_counter()\n", - " frames = make_ring_2d_persistent_initial(seed, n_beads=n_beads)\n", - " timings[\"2_md_relax\"] = time.perf_counter() - t0\n", - "\n", - " last_coords = frames[-1]\n", - "\n", - " t0 = time.perf_counter()\n", - " crossings = find_polyline_crossings(last_coords[:, :2])\n", - " timings[\"3_crossing_detect\"] = time.perf_counter() - t0\n", - "\n", - " t0 = time.perf_counter()\n", - " chain = {\n", - " \"seed\": seed,\n", - " \"n_beads\": n_beads,\n", - " \"coords\": last_coords,\n", - " \"crossings\": crossings,\n", - " }\n", - " render_chain_and_masks(\n", - " chain,\n", - " noise_source=\"none\",\n", - " noise_asset=None,\n", - " )\n", - " timings[\"4_afm_render_masks\"] = time.perf_counter() - t0\n", - "\n", - " return timings\n", - "\n", - "\n", - "def benchmark_pipeline(\n", - " seed: int,\n", - " n_beads: int,\n", - " n_reps: int = 3,\n", - " total_samples: int | None = None,\n", - " print_report: bool = True,\n", - ") -> dict[str, Any]:\n", - " \"\"\"Benchmark the sample-generation pipeline and report timing statistics.\n", - "\n", - " This function prints a system profile, runs repeated benchmark passes for\n", - " one representative sample configuration, tracks peak RSS memory usage, and\n", - " estimates the total runtime for the full dataset.\n", - "\n", - " Parameters\n", - " ----------\n", - " seed : int\n", - " Base random seed for the benchmark runs.\n", - " n_beads : int\n", - " Number of beads used in each benchmarked sample.\n", - " n_reps : int, optional\n", - " Number of benchmark repetitions, by default ``3``.\n", - " total_samples : int or None, optional\n", - " Total number of samples to use when projecting full runtime. If\n", - " ``None``, the projection is omitted.\n", - " print_report : bool, optional\n", - " Whether to print the system and benchmark summary, by default ``True``.\n", - "\n", - " Returns\n", - " -------\n", - " dict[str, Any]\n", - " Dictionary containing benchmark results, including wall times, stage\n", - " timings, median runtime, peak RSS memory, and projected total runtime.\n", - "\n", - " Notes\n", - " -----\n", - " When ``USE_MD`` is enabled, the function also reports available OpenMM\n", - " platforms and uses the same MD settings as the rest of the notebook.\n", - "\n", - " Examples\n", - " --------\n", - " >>> results = benchmark_pipeline(seed=0, n_beads=300, n_reps=3)\n", - " >>> results[\"median_wall_time_s\"] > 0\n", - " True\n", - "\n", - " \"\"\"\n", - "\n", - " seed = int(seed)\n", - " n_beads = int(n_beads)\n", - " n_reps = int(n_reps)\n", - "\n", - " cpu_logical = psutil.cpu_count(logical=True)\n", - " available_ram_gb = psutil.virtual_memory().available / 1e9\n", - "\n", - " platforms = None\n", - " active_platform = None\n", - " if USE_MD:\n", - " platforms = [\n", - " openmm.Platform.getPlatform(i).getName()\n", - " for i in range(openmm.Platform.getNumPlatforms())\n", - " ]\n", - " active_platform = (\n", - " \"CUDA\" if \"CUDA\" in platforms else\n", - " \"OpenCL\" if \"OpenCL\" in platforms else\n", - " \"CPU\"\n", - " )\n", - "\n", - " if print_report:\n", - " print(\"=\" * 62)\n", - " print(\" SYSTEM PROFILE\")\n", - " print(\"=\" * 62)\n", - " print(f\" OS : {platform.system()} {platform.release()}\")\n", - " print(f\" CPU (logical) : {cpu_logical} cores\")\n", - " print(f\" RAM available : {available_ram_gb:.1f} GB\")\n", - " if USE_MD:\n", - " print(f\" OpenMM Platforms: {platforms}\")\n", - " print(f\" Active Platform : {active_platform}\")\n", - " print(f\" Mode : {'MD (OpenMM)' if USE_MD else 'Non-MD (2D Walk)'}\")\n", - " print()\n", - "\n", - " print(\"=\" * 62)\n", - " print(\" RUNNING BENCHMARK\")\n", - " print(\"=\" * 62)\n", - "\n", - " wall_times: list[float] = []\n", - " stage_timings: list[dict[str, float]] = []\n", - "\n", - " mem_tracker = _PeakMemTracker()\n", - " mem_tracker.start()\n", - "\n", - " for rep in range(n_reps):\n", - " rep_seed = seed + rep\n", - " t0 = time.perf_counter()\n", - " rep_stage_timings = _bench_stages(rep_seed, n_beads)\n", - " elapsed = time.perf_counter() - t0\n", - "\n", - " wall_times.append(elapsed)\n", - " stage_timings.append(rep_stage_timings)\n", - "\n", - " if print_report:\n", - " print(f\" Rep {rep + 1}/{n_reps}: {elapsed:.2f}s\")\n", - "\n", - " mem_tracker.stop()\n", - "\n", - " median_wall_time_s = statistics.median(wall_times)\n", - " mean_wall_time_s = statistics.mean(wall_times)\n", - "\n", - " stage_keys = stage_timings[0].keys() if stage_timings else []\n", - " median_stage_times_s = {\n", - " key: statistics.median(t[key] for t in stage_timings)\n", - " for key in stage_keys\n", - " }\n", - " ts = total_samples\n", - " projected_total_hours = None\n", - " if ts is not None:\n", - " projected_total_hours = (median_wall_time_s * int(ts)) / 3600\n", - "\n", - " if print_report:\n", - " print(\"=\" * 62)\n", - " print(f\" Median Wall Time: {median_wall_time_s:.2f} s\")\n", - " print(f\" Mean Wall Time : {mean_wall_time_s:.2f} s\")\n", - " print(f\" Peak RAM (RSS) : {mem_tracker.peak_mb:.1f} MB\")\n", - " if projected_total_hours is not None:\n", - " print(\n", - " f\" Projected Total : {projected_total_hours:.1f} hours \"\n", - " f\"for {int(ts)} samples\"\n", - " )\n", - " print(\"=\" * 62)\n", - "\n", - " return {\n", - " \"seed\": seed,\n", - " \"n_beads\": n_beads,\n", - " \"n_reps\": n_reps,\n", - " \"mode\": \"md\" if USE_MD else \"non_md\",\n", - " \"cpu_logical\": cpu_logical,\n", - " \"available_ram_gb\": available_ram_gb,\n", - " \"openmm_platforms\": platforms,\n", - " \"active_platform\": active_platform,\n", - " \"wall_times_s\": wall_times,\n", - " \"stage_timings_s\": stage_timings,\n", - " \"median_wall_time_s\": median_wall_time_s,\n", - " \"mean_wall_time_s\": mean_wall_time_s,\n", - " \"median_stage_times_s\": median_stage_times_s,\n", - " \"peak_rss_mb\": mem_tracker.peak_mb,\n", - " \"total_samples\": int(ts) if ts is not None else None,\n", - " \"projected_total_hours\": projected_total_hours,\n", - " }\n", - "\n", - "\n", - "BENCH_SEED = int(BASE_SEED)\n", - "BENCH_N_BEADS = int(BEAD_COUNTS[0])\n", - "BENCH_REPS = 3\n", - "\n", - "benchmark_results = benchmark_pipeline(\n", - " seed=BENCH_SEED,\n", - " n_beads=BENCH_N_BEADS,\n", - " n_reps=BENCH_REPS,\n", - " total_samples=int(N_SAMPLES) * len(BEAD_COUNTS),\n", - " print_report=True,\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "cell_md_12", - "metadata": { - "id": "cell_md_12" - }, - "source": [ - "## 14.Dataset Generation\n", - "\n", - "Finally, we are ready to generate the full dataset. The amount of samples and the lenghts of the chains is defined in the global variables and will be referenced here.\n", - "This notebook generates the full dataset (default: 1000 samples × 4 chain lengths). There is added functionality to preview the images for a gives set or range of indices.\n", - "\n", - "\n", - "Progress is printed every 10 samples and a `manifest.csv` tracks all file paths." - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "id": "cell_code_12", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "cell_code_12", - "outputId": "46413bf7-4565-4337-f7e6-a21e8c4ac849" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Starting dataset generation: 100 samples...\n", - "Progress: 10/100\n", - "Progress: 20/100\n", - "Progress: 30/100\n", - "Progress: 40/100\n", - "Skipping seed 42 due to OpenMMException: Energy or force at minimization starting point is infinite or NaN.\n", - "Progress: 50/100\n", - "Progress: 60/100\n", - "Progress: 70/100\n", - "Progress: 80/100\n", - "Progress: 90/100\n", - "Progress: 100/100\n", - "\n", - "Done. Dataset written to: dna_dataset_100_4lengths_MD\n", - "Manifest: dna_dataset_100_4lengths_MD\\manifest.csv\n" - ] - } - ], - "source": [ - "import csv\n", - "import json\n", - "import os\n", - "import subprocess\n", - "import sys\n", - "import time\n", - "from concurrent.futures import TimeoutError as FutureTimeoutError\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "try:\n", - " from joblib.externals.loky import get_reusable_executor\n", - "except ImportError:\n", - " subprocess.check_call(\n", - " [sys.executable, \"-m\", \"pip\", \"install\", \"joblib\"]\n", - " )\n", - " from joblib.externals.loky import get_reusable_executor\n", - "\n", - "\n", - "SAMPLE_TIMEOUT_S = 10.0 #How long to wait for every seed before skipping\n", - "_SAMPLE_EXECUTOR = None\n", - "\n", - "\n", - "def get_sample_executor():\n", - " \"\"\"Return the reusable process executor for sample generation.\n", - "\n", - " The executor runs sample generation in a separate Python process.\n", - " This makes the timeout independent of operating-system-specific\n", - " signal handling, so it works on Linux, macOS, and Windows.\n", - "\n", - " Returns\n", - " -------\n", - " loky.reusable_executor._ReusablePoolExecutor\n", - " Executor used to run one simulation task at a time.\n", - "\n", - " Notes\n", - " -----\n", - " The executor is created only when it is actually needed. After that, the\n", - " same executor is reused for future samples. That avoids creating a\n", - " brand-new process for every seed, which would be much slower.\n", - "\n", - " \"\"\"\n", - "\n", - " global _SAMPLE_EXECUTOR\n", - "\n", - " if _SAMPLE_EXECUTOR is None:\n", - " _SAMPLE_EXECUTOR = get_reusable_executor(max_workers=1)\n", - "\n", - " return _SAMPLE_EXECUTOR\n", - "\n", - "\n", - "def reset_sample_executor():\n", - " \"\"\"Shut down and recreate the sample-generation process pool.\n", - "\n", - " This is called after a timeout or worker-side exception. Killing the\n", - " worker prevents a long-running OpenMM calculation from continuing in\n", - " the background after the seed has already been skipped.\n", - "\n", - " Returns\n", - " -------\n", - " None\n", - "\n", - " \"\"\"\n", - "\n", - " global _SAMPLE_EXECUTOR\n", - "\n", - " if _SAMPLE_EXECUTOR is not None:\n", - " _SAMPLE_EXECUTOR.shutdown(\n", - " wait=False,\n", - " kill_workers=True,\n", - " )\n", - "\n", - " _SAMPLE_EXECUTOR = None\n", - "\n", - "\n", - "def generate_sample_worker(seed, n_beads, add_decoy):\n", - " \"\"\"Generate one DNA sample inside the worker process.\n", - "\n", - " Parameters\n", - " ----------\n", - " seed : int\n", - " Random seed used by the DNA simulator.\n", - " n_beads : int\n", - " Number of beads in the simulated DNA chain.\n", - " add_decoy : bool\n", - " Whether an additional decoy DNA chain should be included.\n", - "\n", - " Returns\n", - " -------\n", - " dict\n", - " Sample dictionary returned by ``generate_one_sample_multilength``.\n", - " It is expected to contain ``afm_img``, ``dna_mask``,\n", - " ``cross_mask``, ``seed``, ``n_beads``, ``extent``, and\n", - " ``n_crossings``.\n", - "\n", - " \"\"\"\n", - "\n", - " return generate_one_sample_multilength(\n", - " int(seed),\n", - " n_beads=int(n_beads),\n", - " noise_source=noise_source,\n", - " noise_asset=noise_asset,\n", - " add_decoy=bool(add_decoy),\n", - " )\n", - "\n", - "\n", - "def generate_sample_with_timeout(seed, n_beads, add_decoy):\n", - " \"\"\"Generate and validate one DNA sample with a time limit.\n", - "\n", - " The simulation is submitted to a separate process. If it does not\n", - " finish within ``SAMPLE_TIMEOUT_S`` seconds, the worker is killed and\n", - " the caller can skip the seed. Exceptions raised by OpenMM or by the\n", - " simulation code are also propagated so the seed can be skipped.\n", - "\n", - " Parameters\n", - " ----------\n", - " seed : int\n", - " Candidate random seed for the sample.\n", - " n_beads : int\n", - " Number of beads to simulate.\n", - " add_decoy : bool\n", - " Whether to add a decoy chain to this sample.\n", - "\n", - " Returns\n", - " -------\n", - " dict\n", - " Validated generated sample.\n", - "\n", - " Raises\n", - " ------\n", - " TimeoutError\n", - " If sample generation takes longer than ``SAMPLE_TIMEOUT_S``.\n", - " ValueError\n", - " If one of the output arrays contains non-finite values.\n", - " Exception\n", - " Re-raises any exception from the simulator.\n", - "\n", - " \"\"\"\n", - "\n", - " executor = get_sample_executor()\n", - " start_time = time.perf_counter()\n", - "\n", - " future = executor.submit(\n", - " generate_sample_worker,\n", - " int(seed),\n", - " int(n_beads),\n", - " bool(add_decoy),\n", - " )\n", - "\n", - " try:\n", - " sample = future.result(timeout=SAMPLE_TIMEOUT_S)\n", - " except FutureTimeoutError as exc:\n", - " future.cancel()\n", - " reset_sample_executor()\n", - " raise TimeoutError(\"Simulation took too long!\") from exc\n", - " except Exception:\n", - " future.cancel()\n", - " reset_sample_executor()\n", - " raise\n", - "\n", - " elapsed = time.perf_counter() - start_time\n", - "\n", - " if elapsed > SAMPLE_TIMEOUT_S:\n", - " reset_sample_executor()\n", - " raise TimeoutError(\"Simulation took too long!\")\n", - "\n", - " for key in (\"afm_img\", \"dna_mask\", \"cross_mask\"):\n", - " arr = np.asarray(sample[key])\n", - " if not np.all(np.isfinite(arr)):\n", - " raise ValueError(f\"Non-finite values found in {key}\")\n", - "\n", - " return sample\n", - "\n", - "\n", - "def save_preview_png(sample, idx, preview_dir):\n", - " \"\"\"Save visual PNG file previews for generated samples.\n", - "\n", - " The preview is useful for quickly checking that the generated AFM\n", - " image looks reasonable without opening the NumPy arrays manually.\n", - " This function only saves the AFM image, not the masks.\n", - "\n", - " Parameters\n", - " ----------\n", - " sample : dict\n", - " Generated sample dictionary containing ``afm_img``.\n", - " idx : int\n", - " Dataset index used to name the preview file.\n", - " preview_dir : str\n", - " Directory where preview PNG files are written.\n", - "\n", - " Returns\n", - " -------\n", - " str\n", - " Path to the written preview PNG file.\n", - "\n", - " \"\"\"\n", - "\n", - " preview_path = os.path.join(\n", - " preview_dir,\n", - " f\"preview_{idx:04d}.png\",\n", - " )\n", - "\n", - " plt.figure(figsize=(5, 5))\n", - " plt.imshow(sample[\"afm_img\"], cmap=\"gray\")\n", - " plt.axis(\"off\")\n", - " plt.tight_layout()\n", - " plt.savefig(preview_path, dpi=150)\n", - " plt.close()\n", - "\n", - " return preview_path\n", - "\n", - "manifest_path = os.path.join(OUT_DIR, \"manifest.csv\")\n", - "print(f\"Starting dataset generation: {N_SAMPLES} samples...\")\n", - "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "# Choose indices to export as PNG previews.\n", - "# Examples:\n", - "# set(range(4, 41)) -> export indices 4 through 40 inclusive\n", - "# {0, 3, 10, 25} -> export only specific indices\n", - "# set() -> export none\n", - "EXPORT_PREVIEW_PNGS = False\n", - "PREVIEW_PNG_INDICES = set(range(4, 8))\n", - "PREVIEW_PNG_DIR = os.path.join(OUT_DIR, \"preview_pngs\")\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "\n", - "for subdir in (\"images\", \"dna_masks\", \"cross_masks\", \"meta\"):\n", - " os.makedirs(os.path.join(OUT_DIR, subdir), exist_ok=True)\n", - "\n", - "if EXPORT_PREVIEW_PNGS:\n", - " os.makedirs(PREVIEW_PNG_DIR, exist_ok=True)\n", - "\n", - "header = [\n", - " \"index\",\n", - " \"seed\",\n", - " \"n_beads\",\n", - " \"bond_length\",\n", - " \"persistence_bonds\",\n", - " \"image_npy\",\n", - " \"dna_mask_npy\",\n", - " \"cross_mask_npy\",\n", - " \"meta_npz\",\n", - " \"n_crossings\",\n", - " \"has_decoy\",\n", - " \"afm_params_json\",\n", - "]\n", - "\n", - "with open(manifest_path, \"w\", newline=\"\") as f:\n", - " writer = csv.writer(f)\n", - " writer.writerow(header)\n", - "\n", - " idx = 0\n", - " current_seed = int(BASE_SEED)\n", - "\n", - " while idx < int(N_SAMPLES):\n", - " n_beads = int(BEAD_COUNTS[idx % len(BEAD_COUNTS)])\n", - " add_decoy = bool(idx % 4 == 0)\n", - "\n", - " try:\n", - " sample = generate_sample_with_timeout(\n", - " current_seed,\n", - " n_beads,\n", - " add_decoy,\n", - " )\n", - "\n", - " img_path = os.path.join(\"images\", f\"img_{idx:04d}.npy\")\n", - " dna_path = os.path.join(\"dna_masks\", f\"dna_{idx:04d}.npy\")\n", - " cross_path = os.path.join(\n", - " \"cross_masks\",\n", - " f\"cross_{idx:04d}.npy\",\n", - " )\n", - " meta_path = os.path.join(\"meta\", f\"meta_{idx:04d}.npz\")\n", - "\n", - " np.save(os.path.join(OUT_DIR, img_path), sample[\"afm_img\"])\n", - " np.save(os.path.join(OUT_DIR, dna_path), sample[\"dna_mask\"])\n", - " np.save(\n", - " os.path.join(OUT_DIR, cross_path),\n", - " sample[\"cross_mask\"],\n", - " )\n", - "\n", - " np.savez_compressed(\n", - " os.path.join(OUT_DIR, meta_path),\n", - " seed=sample[\"seed\"],\n", - " n_beads=int(sample[\"n_beads\"]),\n", - " extent=sample[\"extent\"],\n", - " n_crossings=sample[\"n_crossings\"],\n", - " has_decoy=add_decoy,\n", - " bond_length=BOND_LENGTH,\n", - " persistence=PERSISTENCE_BONDS,\n", - " )\n", - "\n", - " afm_params = globals().get(\n", - " \"AF_KW\",\n", - " globals().get(\"AFM_KW\", {}),\n", - " )\n", - "\n", - " writer.writerow(\n", - " [\n", - " idx,\n", - " current_seed,\n", - " n_beads,\n", - " BOND_LENGTH,\n", - " PERSISTENCE_BONDS,\n", - " img_path,\n", - " dna_path,\n", - " cross_path,\n", - " meta_path,\n", - " sample[\"n_crossings\"],\n", - " add_decoy,\n", - " json.dumps(afm_params, default=str),\n", - " ]\n", - " )\n", - "\n", - " if EXPORT_PREVIEW_PNGS and idx in PREVIEW_PNG_INDICES:\n", - " save_preview_png(\n", - " sample,\n", - " idx,\n", - " PREVIEW_PNG_DIR,\n", - " )\n", - "\n", - " if (idx + 1) % 10 == 0:\n", - " print(f\"Progress: {idx + 1}/{N_SAMPLES}\")\n", - "\n", - " idx += 1\n", - " current_seed += 1\n", - "\n", - " except Exception as exc:\n", - " print(\n", - " f\"Skipping seed {current_seed} due to \"\n", - " f\"{type(exc).__name__}: {exc}\"\n", - " )\n", - " current_seed += 1\n", - " continue\n", - "\n", - "reset_sample_executor()\n", - "\n", - "print(\"\\nDone. Dataset written to:\", OUT_DIR)\n", - "print(\"Manifest:\", manifest_path)" - ] - }, - { - "cell_type": "markdown", - "id": "5boiiKowhLPJ", - "metadata": { - "id": "5boiiKowhLPJ" - }, - "source": [ - "## 15. DeepTrack source connection and Deeplay U-Net\n", - "\n", - "Run the dataset-generation cell above first, or point `OUT_DIR` and\n", - "`manifest_path` to an already generated dataset. This section reads the\n", - "manifest written by the simulation notebook, creates DeepTrack sources,\n", - "loads the `.npy` files lazily, and trains a simple Deeplay U-Net." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "-4_NfbGBhLPJ", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "-4_NfbGBhLPJ", - "outputId": "307b0998-0031-4921-f736-f8524c6048e4" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Requirement already satisfied: deeptrack in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (2.0.1)\n", - "Requirement already satisfied: deeplay in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (0.1.4)\n", - "Requirement already satisfied: lightning in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (2.6.1)\n", - "Requirement already satisfied: pandas in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (2.3.3)\n", - "Requirement already satisfied: pillow in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (12.2.0)\n", - "Requirement already satisfied: numpy in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from deeptrack) (2.2.6)\n", - "Requirement already satisfied: matplotlib in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from deeptrack) (3.10.9)\n", - "Requirement already satisfied: scipy in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from deeptrack) (1.15.3)\n", - "Requirement already satisfied: scikit-image in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from deeptrack) (0.25.2)\n", - "Requirement already satisfied: more_itertools in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from deeptrack) (11.0.2)\n", - "Requirement already satisfied: pint in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from deeptrack) (0.24.4)\n", - "Requirement already satisfied: tqdm in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from deeptrack) (4.67.3)\n", - "Requirement already satisfied: lazy_import in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from deeptrack) (0.2.2)\n", - "Requirement already satisfied: rich in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from deeptrack) (15.0.0)\n", - "Requirement already satisfied: gdown in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from deeptrack) (6.0.0)\n", - "Requirement already satisfied: torch>2.3 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from deeplay) (2.12.0+cu132)\n", - "Requirement already satisfied: torchmetrics in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from deeplay) (1.9.0)\n", - "Requirement already satisfied: torchvision in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from deeplay) (0.27.0+cu132)\n", - "Requirement already satisfied: torch-geometric in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from deeplay) (2.7.0)\n", - "Requirement already satisfied: kornia in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from deeplay) (0.8.2)\n", - "Requirement already satisfied: dill in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from deeplay) (0.4.1)\n", - "Requirement already satisfied: PyYAML<8.0,>5.4 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from lightning) (6.0.3)\n", - "Requirement already satisfied: fsspec<2028.0,>=2022.5.0 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from fsspec[http]<2028.0,>=2022.5.0->lightning) (2026.4.0)\n", - "Requirement already satisfied: lightning-utilities<2.0,>=0.10.0 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from lightning) (0.15.3)\n", - "Requirement already satisfied: packaging<27.0,>=23.0 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from lightning) (26.0)\n", - "Requirement already satisfied: typing-extensions<6.0,>4.5.0 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from lightning) (4.15.0)\n", - "Requirement already satisfied: pytorch-lightning in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from lightning) (2.6.1)\n", - "Requirement already satisfied: aiohttp!=4.0.0a0,!=4.0.0a1 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from fsspec[http]<2028.0,>=2022.5.0->lightning) (3.13.5)\n", - "Requirement already satisfied: filelock in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from torch>2.3->deeplay) (3.29.0)\n", - "Requirement already satisfied: setuptools<82 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from torch>2.3->deeplay) (81.0.0)\n", - "Requirement already satisfied: sympy>=1.13.3 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from torch>2.3->deeplay) (1.14.0)\n", - "Requirement already satisfied: networkx>=2.5.1 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from torch>2.3->deeplay) (3.4.2)\n", - "Requirement already satisfied: jinja2 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from torch>2.3->deeplay) (3.1.6)\n", - "Requirement already satisfied: colorama in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from tqdm->deeptrack) (0.4.6)\n", - "Requirement already satisfied: python-dateutil>=2.8.2 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from pandas) (2.9.0.post0)\n", - "Requirement already satisfied: pytz>=2020.1 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from pandas) (2026.1.post1)\n", - "Requirement already satisfied: tzdata>=2022.7 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from pandas) (2026.2)\n", - "Requirement already satisfied: aiohappyeyeballs>=2.5.0 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<2028.0,>=2022.5.0->lightning) (2.6.1)\n", - "Requirement already satisfied: aiosignal>=1.4.0 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<2028.0,>=2022.5.0->lightning) (1.4.0)\n", - "Requirement already satisfied: async-timeout<6.0,>=4.0 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<2028.0,>=2022.5.0->lightning) (5.0.1)\n", - "Requirement already satisfied: attrs>=17.3.0 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<2028.0,>=2022.5.0->lightning) (26.1.0)\n", - "Requirement already satisfied: frozenlist>=1.1.1 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<2028.0,>=2022.5.0->lightning) (1.8.0)\n", - "Requirement already satisfied: multidict<7.0,>=4.5 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<2028.0,>=2022.5.0->lightning) (6.7.1)\n", - "Requirement already satisfied: propcache>=0.2.0 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<2028.0,>=2022.5.0->lightning) (0.4.1)\n", - "Requirement already satisfied: yarl<2.0,>=1.17.0 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<2028.0,>=2022.5.0->lightning) (1.23.0)\n", - "Requirement already satisfied: idna>=2.0 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from yarl<2.0,>=1.17.0->aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<2028.0,>=2022.5.0->lightning) (3.13)\n", - "Requirement already satisfied: six>=1.5 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from python-dateutil>=2.8.2->pandas) (1.17.0)\n", - "Requirement already satisfied: mpmath<1.4,>=1.1.0 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from sympy>=1.13.3->torch>2.3->deeplay) (1.3.0)\n", - "Requirement already satisfied: beautifulsoup4 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from gdown->deeptrack) (4.14.3)\n", - "Requirement already satisfied: requests[socks] in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from gdown->deeptrack) (2.33.1)\n", - "Requirement already satisfied: soupsieve>=1.6.1 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from beautifulsoup4->gdown->deeptrack) (2.8.3)\n", - "Requirement already satisfied: MarkupSafe>=2.0 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from jinja2->torch>2.3->deeplay) (3.0.3)\n", - "Requirement already satisfied: kornia_rs>=0.1.9 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from kornia->deeplay) (0.1.11)\n", - "Requirement already satisfied: contourpy>=1.0.1 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from matplotlib->deeptrack) (1.3.2)\n", - "Requirement already satisfied: cycler>=0.10 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from matplotlib->deeptrack) (0.12.1)\n", - "Requirement already satisfied: fonttools>=4.22.0 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from matplotlib->deeptrack) (4.62.1)\n", - "Requirement already satisfied: kiwisolver>=1.3.1 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from matplotlib->deeptrack) (1.5.0)\n", - "Requirement already satisfied: pyparsing>=3 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from matplotlib->deeptrack) (3.3.2)\n", - "Requirement already satisfied: platformdirs>=2.1.0 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from pint->deeptrack) (4.9.4)\n", - "Requirement already satisfied: flexcache>=0.3 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from pint->deeptrack) (0.3)\n", - "Requirement already satisfied: flexparser>=0.4 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from pint->deeptrack) (0.4)\n", - "Requirement already satisfied: charset_normalizer<4,>=2 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from requests[socks]->gdown->deeptrack) (3.4.7)\n", - "Requirement already satisfied: urllib3<3,>=1.26 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from requests[socks]->gdown->deeptrack) (2.6.3)\n", - "Requirement already satisfied: certifi>=2023.5.7 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from requests[socks]->gdown->deeptrack) (2026.4.22)\n", - "Requirement already satisfied: PySocks!=1.5.7,>=1.5.6 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from requests[socks]->gdown->deeptrack) (1.7.1)\n", - "Requirement already satisfied: markdown-it-py>=2.2.0 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from rich->deeptrack) (4.0.0)\n", - "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from rich->deeptrack) (2.20.0)\n", - "Requirement already satisfied: mdurl~=0.1 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from markdown-it-py>=2.2.0->rich->deeptrack) (0.1.2)\n", - "Requirement already satisfied: imageio!=2.35.0,>=2.33 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from scikit-image->deeptrack) (2.37.3)\n", - "Requirement already satisfied: tifffile>=2022.8.12 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from scikit-image->deeptrack) (2025.5.10)\n", - "Requirement already satisfied: lazy-loader>=0.4 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from scikit-image->deeptrack) (0.5)\n", - "Requirement already satisfied: psutil>=5.8.0 in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from torch-geometric->deeplay) (7.2.2)\n", - "Requirement already satisfied: xxhash in c:\\users\\xdutpr\\onedrive - chalmers\\afm_pipeline\\dna-afm.venv\\lib\\site-packages (from torch-geometric->deeplay) (3.7.0)\n" - ] - } - ], - "source": [ - "# Install these in a fresh Colab/Kaggle runtime.\n", - "!pip install deeptrack deeplay lightning pandas pillow" - ] - }, - { - "cell_type": "markdown", - "id": "5vJg1TV5u_ML", - "metadata": { - "id": "5vJg1TV5u_ML" - }, - "source": [ - "...and then we load the required dependencies and set up the model hyperparameters..." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "KMncGnXzhLPM", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 356 - }, - "id": "KMncGnXzhLPM", - "outputId": "407e665f-296c-49ad-c614-7172947e3fa7" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\Users\\xdutpr\\OneDrive - Chalmers\\AFM_pipeline\\dna-afm.venv\\lib\\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", - "WARNING:pint.util:Redefining '[magnetic_flux]' ()\n", - "Seed set to 7\n" - ] - } - ], - "source": [ - "from pathlib import Path\n", - "from typing import Any\n", - "\n", - "import random\n", - "\n", - "import deeplay as dl\n", - "import deeptrack as dt\n", - "import lightning as L\n", - "import numpy as np\n", - "import pandas as pd\n", - "import torch\n", - "import torch.nn as nn\n", - "import torch.nn.functional as F\n", - "from PIL import Image\n", - "from torch.utils.data import Dataset\n", - "\n", - "SEED = 7 #Seed for reproducibility\n", - "\n", - "L.seed_everything(SEED, workers=True)\n", - "random.seed(SEED)\n", - "np.random.seed(SEED)\n", - "torch.manual_seed(SEED)\n", - "\n", - "manifest_path = Path(OUT_DIR) / \"manifest.csv\"\n", - "\n", - "TARGET_SIZE = int(NX)\n", - "VAL_FRACTION = 0.20 #This corresponds to a 80:20 split of test and validation\n", - "BG_Q = 50 #Quantile for background intensity estimation\n", - "HIGH_Q = 99.97 #Quantile for high intensity clipping\n", - "\n", - "MODEL_CFG = dict(\n", - " in_channels=1,\n", - " channels=[16, 32, 64, 128],\n", - " out_channels=2,\n", - ")\n", - "\n", - "TRAIN_CFG = dict(\n", - " batch_size=4,\n", - " num_workers=0,\n", - " max_epochs=50, #number of training epochs\n", - " lr=1e-3, #Learning rate for the training\n", - " dna_pos_weight=2.0,\n", - " dna_loss_weight=1.0,\n", - " cross_loss_weight=0.08,\n", - " cross_pos_weight=50,\n", - " dice_smooth=1.0,\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "g0hlOwRfhLPM", - "metadata": { - "id": "g0hlOwRfhLPM" - }, - "source": [ - "### 16. Build DeepTrack sources from the simulation manifest\n", - "\n", - "The original manifest columns are `image_npy`, `dna_mask_npy`, and\n", - "`cross_mask_npy`. They are relative paths, so the loader joins them with\n", - "`OUT_DIR` before reading the files." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "Y3bgtN9MhLPM", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "Y3bgtN9MhLPM", - "outputId": "1beac707-db78-4993-9af4-fba5779f10ee" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total samples: 100\n", - "Training samples: 80\n", - "Validation samples: 20\n", - "First source row: {'id': '0', 'image_path': 'dna_dataset_100_4lengths_MD\\\\images\\\\img_0000.npy', 'dna_path': 'dna_dataset_100_4lengths_MD\\\\dna_masks\\\\dna_0000.npy', 'cross_path': 'dna_dataset_100_4lengths_MD\\\\cross_masks\\\\cross_0000.npy'}\n" - ] - } - ], - "source": [ - "IMAGE_COLUMNS = (\n", - " 'image_npy',\n", - " 'image_path',\n", - " 'img_path',\n", - " 'afm_path',\n", - ")\n", - "\n", - "DNA_COLUMNS = (\n", - " 'dna_mask_npy',\n", - " 'dna_path',\n", - " 'mask_path',\n", - " 'label_path',\n", - ")\n", - "\n", - "CROSS_COLUMNS = (\n", - " 'cross_mask_npy',\n", - " 'cross_path',\n", - " 'crossing_path',\n", - ")\n", - "\n", - "\n", - "def find_column(\n", - " frame: pd.DataFrame,\n", - " candidates: tuple[str, ...],\n", - " required: bool = True,\n", - ") -> str | None:\n", - " \"\"\"Return the first matching column in a manifest.\n", - "\n", - " Parameters\n", - " ----------\n", - " frame : pd.DataFrame\n", - " The dataframe to search for columns.\n", - " candidates : tuple[str, ...]\n", - " A tuple of potential column names to match.\n", - " required : bool, optional\n", - " If True, raises a KeyError if no matching column is found.\n", - " Defaults to True.\n", - "\n", - " Returns\n", - " -------\n", - " str | None\n", - " The name of the first matching column found, or None if no\n", - " match is found and `required` is False.\n", - "\n", - " Raises\n", - " ------\n", - " KeyError\n", - " If `required` is True and none of the `candidates` exist in `frame`.\n", - "\n", - " \"\"\"\n", - "\n", - " for column in candidates:\n", - " if column in frame.columns:\n", - " return column\n", - "\n", - " if required:\n", - " names = ', '.join(candidates)\n", - " raise KeyError(f'Manifest is missing one of: {names}')\n", - "\n", - " return None\n", - "\n", - "\n", - "def resolve_data_path(value: Any, root: Path) -> Path:\n", - " \"\"\"Resolve an absolute or OUT_DIR-relative file path.\n", - "\n", - " Parameters\n", - " ----------\n", - " value: any\n", - " The value to resolve.\n", - " root: Path\n", - " The root directory.\n", - "\n", - " Returns\n", - " -------\n", - " Path\n", - " The resolved path.\n", - "\n", - " \"\"\"\n", - "\n", - " path = Path(str(value))\n", - "\n", - " if path.is_absolute():\n", - " return path\n", - "\n", - " return Path(root) / path\n", - "\n", - "\n", - "def manifest_to_records(\n", - " frame: pd.DataFrame,\n", - " root: Path,\n", - ") -> list[dict[str, str]]:\n", - " \"\"\"Convert the simulation manifest to DeepTrack source rows.\n", - "\n", - " Parameters\n", - " ----------\n", - " frame: pd.dataframe\n", - " The simulation manifest.\n", - " root: Path\n", - " The root directory.\n", - "\n", - " Returns\n", - " -------\n", - " list[dict[str, str]]\n", - " A list of DeepTrack source rows.\n", - "\n", - " \"\"\"\n", - "\n", - " image_col = find_column(frame, IMAGE_COLUMNS)\n", - " dna_col = find_column(frame, DNA_COLUMNS)\n", - " cross_col = find_column(frame, CROSS_COLUMNS, required=False)\n", - " records = []\n", - " missing = []\n", - "\n", - " for row_index, row in frame.iterrows():\n", - " image_path = resolve_data_path(row[image_col], root)\n", - " dna_path = resolve_data_path(row[dna_col], root)\n", - " cross_path = ''\n", - "\n", - " if cross_col is not None and not pd.isna(row[cross_col]):\n", - " cross_path = str(resolve_data_path(row[cross_col], root))\n", - "\n", - " if not image_path.exists():\n", - " missing.append(str(image_path))\n", - " continue\n", - "\n", - " if not dna_path.exists():\n", - " missing.append(str(dna_path))\n", - " continue\n", - "\n", - " if cross_path and not Path(cross_path).exists():\n", - " missing.append(cross_path)\n", - " cross_path = ''\n", - "\n", - " sample_id = str(row.get('index', row_index))\n", - " records.append(\n", - " dict(\n", - " id=sample_id,\n", - " image_path=str(image_path),\n", - " dna_path=str(dna_path),\n", - " cross_path=cross_path,\n", - " )\n", - " )\n", - "\n", - " if missing:\n", - " preview = '\\n'.join(missing[:10])\n", - " raise FileNotFoundError(\n", - " 'Some manifest files could not be found. First missing files:\\n'\n", - " f'{preview}'\n", - " )\n", - "\n", - " if not records:\n", - " raise RuntimeError('No valid samples were found in the manifest.')\n", - "\n", - " return records\n", - "\n", - "\n", - "def split_records(\n", - " records: list[dict[str, str]],\n", - " val_fraction: float,\n", - " seed: int,\n", - ") -> tuple[list[dict[str, str]], list[dict[str, str]]]:\n", - " \"\"\"Split records into train and validation lists.\n", - "\n", - " Parameters\n", - " ----------\n", - " records: list\n", - " A list of DeepTrack source rows.\n", - " val_fraction: float\n", - " The fraction for the split between training and validation.\n", - " seed: int\n", - " Random seed for reproducibility.\n", - "\n", - " Returns\n", - " -------\n", - " tuple[list[dict[str, str]], list[dict[str, str]]]\n", - " A tuple of train and validation lists.\n", - "\n", - " \"\"\"\n", - "\n", - " if len(records) < 2:\n", - " return records, records\n", - "\n", - " rng = np.random.default_rng(seed)\n", - " order = rng.permutation(len(records))\n", - " n_val = max(1, int(round(len(records) * val_fraction)))\n", - " n_val = min(n_val, len(records) - 1)\n", - " val_index = set(int(i) for i in order[:n_val])\n", - " train_rows = []\n", - " val_rows = []\n", - "\n", - " for index, record in enumerate(records):\n", - " if index in val_index:\n", - " val_rows.append(record)\n", - " else:\n", - " train_rows.append(record)\n", - "\n", - " return train_rows, val_rows\n", - "\n", - "\n", - "manifest_file = Path(manifest_path)\n", - "dataset_root = Path(OUT_DIR)\n", - "\n", - "if not manifest_file.exists():\n", - " raise FileNotFoundError(\n", - " 'Run the dataset-generation cell first, or set manifest_path to an '\n", - " f'existing manifest. Current value: {manifest_file}'\n", - " )\n", - "\n", - "manifest_df = pd.read_csv(manifest_file)\n", - "all_records = manifest_to_records(manifest_df, dataset_root)\n", - "train_records, val_records = split_records(\n", - " all_records,\n", - " VAL_FRACTION,\n", - " SEED,\n", - ")\n", - "\n", - "train_source = dt.sources.Source(samples=train_records)\n", - "val_source = dt.sources.Source(samples=val_records)\n", - "\n", - "print('Total samples:', len(all_records))\n", - "print('Training samples:', len(train_source))\n", - "print('Validation samples:', len(val_source))\n", - "print('First source row:', train_records[0])" - ] - }, - { - "cell_type": "markdown", - "id": "A_rtdbEChLPM", - "metadata": { - "id": "A_rtdbEChLPM" - }, - "source": [ - "### 17. Lazy `.npy` loading pipeline\n", - "\n", - "The source stores only file paths. `dt.Value(source.samples)` resolves the\n", - "current manifest row, and `dt.Lambda` loads the image and masks lazily. All\n", - "flipped or rotated arrays are converted with `np.ascontiguousarray`, which\n", - "prevents negative-stride errors when creating PyTorch tensors." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "uRSxyqK_hLPM", - "metadata": { - "id": "uRSxyqK_hLPM" - }, - "outputs": [], - "source": [ - "def load_array(path: str | Path) -> np.ndarray:\n", - " \"\"\"Load a NumPy array or image file as a 2-D float32 array.\n", - "\n", - " Parameters\n", - " ----------\n", - " path: str | Path\n", - " The path to the array or image file.\n", - "\n", - " Returns\n", - " -------\n", - " np.ndarray\n", - " The loaded array.\n", - "\n", - " \"\"\"\n", - "\n", - " path = Path(path)\n", - "\n", - " if path.suffix.lower() == '.npy':\n", - " array = np.load(path)\n", - " else:\n", - " with Image.open(path) as image:\n", - " array = np.asarray(image)\n", - "\n", - " array = np.asarray(array)\n", - "\n", - " if array.ndim == 3:\n", - " array = array[..., :3].mean(axis=-1)\n", - "\n", - " array = np.squeeze(array)\n", - " return np.asarray(array, dtype=np.float32)\n", - "\n", - "\n", - "def normalize_afm(\n", - " image: np.ndarray,\n", - " bg_q: float = BG_Q,\n", - " high_q: float = HIGH_Q,\n", - ") -> np.ndarray:\n", - " \"\"\"Normalize an AFM height map using robust percentiles.\n", - "\n", - " This function normalizes the image by converting the pixels below the BG_Q\n", - " percentile to 0 and everything above HIGH_Qth percentile is mapped to 1.\n", - "\n", - " Parameters\n", - " ----------\n", - " image: np.ndarray\n", - " The height map to normalize.\n", - " bg_q: float\n", - " The percentile for the background. Defaults to BG_Q.\n", - " high_q: float\n", - " The percentile for the foreground. Defaults to HIGH_Q.\n", - "\n", - " Returns\n", - " -------\n", - " np.ndarray\n", - " The normalized height map.\n", - "\n", - " \"\"\"\n", - "\n", - " array = np.asarray(image, dtype=np.float32)\n", - " array = np.nan_to_num(array, copy=False)\n", - " low = float(np.percentile(array, bg_q))\n", - " high = float(np.percentile(array, high_q))\n", - " scale = max(high - low, 1e-6)\n", - " array = (array - low) / scale\n", - " return np.clip(array, 0.0, 1.0).astype(np.float32)\n", - "\n", - "\n", - "def resize_and_pad_np(\n", - " array: np.ndarray,\n", - " target_size: int,\n", - " mode: str,\n", - ") -> np.ndarray:\n", - " \"\"\"Resize an array isotropically and pad it to a square.\n", - "\n", - " Parameters\n", - " ----------\n", - " array: np.ndarray\n", - " The image for resizing if necessary.\n", - " target_size: int\n", - " the size of the required image.\n", - " mode: str\n", - " The resize mode.\n", - "\n", - " Returns\n", - " -------\n", - " np.ndarray\n", - " The resized array.\n", - "\n", - " \"\"\"\n", - "\n", - " array = np.asarray(array, dtype=np.float32)\n", - " array = np.nan_to_num(np.squeeze(array), copy=False)\n", - " array = np.ascontiguousarray(array)\n", - " height, width = array.shape[-2:]\n", - " target = int(target_size)\n", - " scale = min(target / height, target / width)\n", - " new_h = max(1, int(round(height * scale)))\n", - " new_w = max(1, int(round(width * scale)))\n", - " tensor = torch.from_numpy(array)[None, None].float()\n", - " kwargs: dict[str, Any] = dict(size=(new_h, new_w), mode=mode)\n", - "\n", - " if mode in {'bilinear', 'bicubic'}:\n", - " kwargs['align_corners'] = False\n", - "\n", - " resized = F.interpolate(tensor, **kwargs)[0, 0].numpy()\n", - " canvas = np.zeros((target, target), dtype=np.float32)\n", - " top = (target - new_h) // 2\n", - " left = (target - new_w) // 2\n", - " canvas[top:top + new_h, left:left + new_w] = resized\n", - " return np.ascontiguousarray(canvas)\n", - "\n", - "\n", - "def augment_triplet(\n", - " image: np.ndarray,\n", - " dna: np.ndarray,\n", - " cross: np.ndarray,\n", - ") -> tuple[np.ndarray, np.ndarray, np.ndarray]:\n", - " \"\"\"Apply the same simple geometric augmentation to all arrays.\n", - "\n", - " Parameters\n", - " ----------\n", - " image: np.ndarray\n", - " The image to augment.\n", - " dna: np.ndarray\n", - " The DNA mask to augment.\n", - " cross: np.ndarray\n", - " The crossing mask to augment.\n", - "\n", - " Returns\n", - " -------\n", - " tuple[np.ndarray, np.ndarray, np.ndarray]\n", - " The augmented arrays.\n", - "\n", - " \"\"\"\n", - "\n", - " if random.random() < 0.5:\n", - " image = np.fliplr(image)\n", - " dna = np.fliplr(dna)\n", - " cross = np.fliplr(cross)\n", - "\n", - " if random.random() < 0.5:\n", - " image = np.flipud(image)\n", - " dna = np.flipud(dna)\n", - " cross = np.flipud(cross)\n", - "\n", - " k = random.randint(0, 3)\n", - " if k:\n", - " image = np.rot90(image, k)\n", - " dna = np.rot90(dna, k)\n", - " cross = np.rot90(cross, k)\n", - "\n", - " return (\n", - " np.ascontiguousarray(image),\n", - " np.ascontiguousarray(dna),\n", - " np.ascontiguousarray(cross),\n", - " )\n", - "\n", - "\n", - "def load_sample_factory(\n", - " target_size: int = 512,\n", - " augment: bool = False,\n", - "):\n", - " \"\"\"Return a DeepTrack Lambda function for one manifest row.\n", - "\n", - " Parameters\n", - " ----------\n", - " target_size : int\n", - " The target size for the images and masks. Defaults to 512.\n", - " augment: bool\n", - " Whether to apply geometric augmentation. Defaults to False.\n", - "\n", - " Returns\n", - " -------\n", - " dt.Lambda\n", - "\n", - " \"\"\"\n", - "\n", - " def load_sample(sample: dict[str, str]):\n", - " image = load_array(sample['image_path'])\n", - " dna = load_array(sample['dna_path'])\n", - " image = normalize_afm(image)\n", - " dna = (dna > 0.5).astype(np.float32)\n", - "\n", - " if sample.get('cross_path'):\n", - " cross = load_array(sample['cross_path'])\n", - " cross = np.nan_to_num(cross, copy=False)\n", - " max_cross = float(np.max(cross))\n", - " if max_cross > 1.0:\n", - " cross = cross / max_cross\n", - " cross = np.clip(cross, 0.0, 1.0).astype(np.float32)\n", - " else:\n", - " cross = np.zeros_like(dna, dtype=np.float32)\n", - "\n", - " if augment:\n", - " image, dna, cross = augment_triplet(image, dna, cross)\n", - "\n", - " image = resize_and_pad_np(image, target_size, 'bilinear')\n", - " dna = resize_and_pad_np(dna, target_size, 'nearest')\n", - " cross = resize_and_pad_np(cross, target_size, 'bilinear')\n", - " dna = (dna > 0.5).astype(np.float32)\n", - " cross = np.clip(cross, 0.0, 1.0).astype(np.float32)\n", - " image = np.ascontiguousarray(image[None, :, :])\n", - " target = np.stack([dna, cross], axis=0)\n", - " target = np.ascontiguousarray(target.astype(np.float32))\n", - " return image.astype(np.float32), target\n", - "\n", - " return load_sample\n", - "\n", - "\n", - "def build_pipeline(source, target_size: int, augment: bool):\n", - " \"\"\"Create a DeepTrack pipeline from a source of manifest rows.\n", - "\n", - " Parameters\n", - " ----------\n", - " source: dt.Source\n", - " The source of manifest rows.\n", - " target_size: int\n", - " The target size for the images and masks.\n", - " augment: bool\n", - " Whether to apply geometric augmentation.\n", - "\n", - " Returns\n", - " -------\n", - " dt.Pipeline\n", - "\n", - " \"\"\"\n", - "\n", - " sample_value = dt.Value(source.samples)\n", - " loader = dt.Lambda(\n", - " function=load_sample_factory,\n", - " target_size=target_size,\n", - " augment=augment,\n", - " )\n", - " return sample_value >> loader" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "bACdP_7khLPM", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "bACdP_7khLPM", - "outputId": "d5fee6cb-d0f8-4e30-bc84-d41bd1b5de3c" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "image batch: (4, 1, 512, 512) torch.float32\n", - "target batch: (4, 2, 512, 512) torch.float32\n", - "target channels: DNA = 0, crossings = 1\n" - ] - } - ], - "source": [ - "class DeepTrackSourceDataset(Dataset):\n", - " \"\"\"PyTorch dataset backed by a DeepTrack source and pipeline.\n", - "\n", - " This dataset connects a DeepTrack ``Source`` to a PyTorch-compatible\n", - " dataset interface. Each item is generated by evaluating a DeepTrack\n", - " pipeline on one source entry. The pipeline is expected to return an\n", - " image and a two-channel target array.\n", - "\n", - " The first target channel should contain the DNA segmentation mask.\n", - " The second target channel should contain the crossing target.\n", - "\n", - " Parameters\n", - " ----------\n", - " source : deeptrack.sources.Source\n", - " DeepTrack source containing one entry per sample.\n", - " target_size : int\n", - " Final spatial size used for image and target tensors.\n", - " augment : bool\n", - " Whether to apply training-time augmentation in the pipeline.\n", - "\n", - " Attributes\n", - " ----------\n", - " source : deeptrack.sources.Source\n", - " Source object used to index sample metadata or paths.\n", - " pipeline : deeptrack.Feature\n", - " DeepTrack pipeline built from ``source``, ``target_size``, and\n", - " ``augment``.\n", - " \"\"\"\n", - "\n", - " def __init__(self, source, target_size: int, augment: bool):\n", - " \"\"\"Initialize the dataset and build the DeepTrack pipeline.\n", - "\n", - " Parameters\n", - " ----------\n", - " source : deeptrack.sources.Source\n", - " DeepTrack source containing one entry per sample.\n", - " target_size : int\n", - " Final spatial size used for image and target tensors.\n", - " augment : bool\n", - " Whether to apply training-time augmentation in the pipeline.\n", - " \"\"\"\n", - " self.source = source\n", - " self.pipeline = build_pipeline(source, target_size, augment)\n", - "\n", - " def __len__(self) -> int:\n", - " \"\"\"Return the number of samples in the DeepTrack source.\n", - "\n", - " Returns\n", - " -------\n", - " int\n", - " Number of source entries available to the dataset.\n", - " \"\"\"\n", - " return len(self.source)\n", - "\n", - " @staticmethod\n", - " def _to_tensor(array: np.ndarray) -> torch.Tensor:\n", - " \"\"\"Convert an array-like object to a contiguous float tensor.\n", - "\n", - " This function also replaces NaN and infinite values with finite\n", - " numbers and ensures the array has positive strides. The positive\n", - " stride conversion is important after NumPy operations such as\n", - " flips or rotations, which can otherwise create views with\n", - " negative strides that PyTorch cannot convert directly.\n", - "\n", - " Parameters\n", - " ----------\n", - " array : np.ndarray\n", - " Array-like image or target returned by the DeepTrack\n", - " pipeline.\n", - "\n", - " Returns\n", - " -------\n", - " torch.Tensor\n", - " Contiguous ``float32`` tensor.\n", - "\n", - " \"\"\"\n", - "\n", - " array = np.asarray(array, dtype=np.float32)\n", - " array = np.nan_to_num(array, copy=False)\n", - " array = np.ascontiguousarray(array)\n", - " return torch.from_numpy(array).float()\n", - "\n", - " def __getitem__(self, index: int):\n", - " \"\"\"Return one image-target pair from the DeepTrack pipeline.\n", - "\n", - " Parameters\n", - " ----------\n", - " index : int\n", - " Index of the source entry to evaluate.\n", - "\n", - " Returns\n", - " -------\n", - " tuple[torch.Tensor, torch.Tensor]\n", - " Image tensor and target tensor. The target tensor is expected\n", - " to contain two channels: DNA mask at channel 0 and crossing\n", - " target at channel 1.\n", - "\n", - " Raises\n", - " ------\n", - " TypeError\n", - " If the DeepTrack pipeline does not return ``(image, target)``.\n", - "\n", - " \"\"\"\n", - "\n", - " self.pipeline.update()\n", - " result = self.pipeline(self.source[index])\n", - "\n", - " if not isinstance(result, (tuple, list)) or len(result) != 2:\n", - " raise TypeError(\"The pipeline must return (image, target).\")\n", - "\n", - " image, target = result\n", - " return self._to_tensor(image), self._to_tensor(target)\n", - "\n", - "\n", - "train_dataset = DeepTrackSourceDataset(\n", - " train_source,\n", - " TARGET_SIZE,\n", - " augment=True,\n", - ")\n", - "\n", - "val_dataset = DeepTrackSourceDataset(\n", - " val_source,\n", - " TARGET_SIZE,\n", - " augment=False,\n", - ")\n", - "\n", - "train_loader = dl.DataLoader(\n", - " train_dataset,\n", - " batch_size=int(TRAIN_CFG['batch_size']),\n", - " shuffle=True,\n", - " num_workers=int(TRAIN_CFG['num_workers']),\n", - " pin_memory=torch.cuda.is_available(),\n", - " persistent_workers=int(TRAIN_CFG['num_workers']) > 0,\n", - ")\n", - "\n", - "val_loader = dl.DataLoader(\n", - " val_dataset,\n", - " batch_size=int(TRAIN_CFG['batch_size']),\n", - " shuffle=False,\n", - " num_workers=int(TRAIN_CFG['num_workers']),\n", - " pin_memory=torch.cuda.is_available(),\n", - " persistent_workers=int(TRAIN_CFG['num_workers']) > 0,\n", - ")\n", - "\n", - "image_batch, target_batch = next(iter(train_loader))\n", - "print('image batch:', tuple(image_batch.shape), image_batch.dtype)\n", - "print('target batch:', tuple(target_batch.shape), target_batch.dtype)\n", - "print('target channels: DNA = 0, crossings = 1')" - ] - }, - { - "cell_type": "markdown", - "id": "5G7C_IGGhLPM", - "metadata": { - "id": "5G7C_IGGhLPM" - }, - "source": [ - "### Deeplay U-Net and multitask loss\n", - "\n", - "The U-Net has one output head with two channels. Channel 0 is the DNA logit\n", - "map and channel 1 is the crossing logit map. DNA uses BCE-Dice loss;\n", - "crossings use a lower-weight MSE term after sigmoid activation." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "ajbx1-S2hLPN", - "metadata": { - "id": "ajbx1-S2hLPN" - }, - "outputs": [], - "source": [ - "def dice_loss_from_logits(\n", - " logits: torch.Tensor,\n", - " target: torch.Tensor,\n", - " smooth: float = 1.0,\n", - ") -> torch.Tensor:\n", - " \"\"\"Soft Dice loss for binary segmentation logits.\n", - "\n", - " Parameters\n", - " ----------\n", - " logits: torch.tensor\n", - " The model logits.\n", - " target: torch.tensor\n", - " The target masks.\n", - " smooth: float\n", - " Smoothing factor. Defaults to 1.0.\n", - "\n", - " Returns\n", - " -------\n", - " torch.tensor\n", - "\n", - " \"\"\"\n", - "\n", - " prob = torch.sigmoid(logits)\n", - " dims = tuple(range(1, prob.ndim))\n", - " inter = torch.sum(prob * target, dim=dims)\n", - " denom = torch.sum(prob, dim=dims) + torch.sum(target, dim=dims)\n", - " dice = (2.0 * inter + smooth) / (denom + smooth)\n", - " return 1.0 - dice.mean()\n", - "\n", - "\n", - "class DNACrossingLoss(nn.Module):\n", - " \"\"\"Compute DNA segmentation and crossing-prediction losses.\n", - "\n", - " This loss combines a BCE-Dice loss for the DNA segmentation channel\n", - " with a weighted mean-squared-error loss for the crossing channel. The\n", - " DNA loss is intended to dominate training, while the crossing loss can\n", - " be kept as a weaker auxiliary objective.\n", - "\n", - " The prediction tensor is expected to contain two channels:\n", - "\n", - " - channel 0: DNA segmentation logits\n", - " - channel 1: crossing logits\n", - "\n", - " The target tensor is expected to contain two matching channels:\n", - "\n", - " - channel 0: binary DNA segmentation mask\n", - " - channel 1: crossing target mask or heatmap\n", - "\n", - " Parameters\n", - " ----------\n", - " dna_pos_weight : float, default=1.0\n", - " Positive-class weight used by the DNA BCE loss. Values greater\n", - " than 1.0 increase the penalty for missing DNA pixels.\n", - " dna_loss_weight : float, default=1.0\n", - " Multiplicative weight applied to the combined BCE-Dice DNA loss.\n", - " cross_loss_weight : float, default=0.10\n", - " Multiplicative weight applied to the crossing MSE loss. Lower\n", - " values make the model focus more strongly on DNA segmentation.\n", - " dice_smooth : float, default=1.0\n", - " Smoothing constant used in the Dice loss to avoid division by\n", - " zero and stabilize training on sparse masks.\n", - "\n", - " Attributes\n", - " ----------\n", - " dna_loss_weight : float\n", - " Weight applied to the DNA segmentation loss.\n", - " cross_loss_weight : float\n", - " Weight applied to the crossing loss.\n", - " dice_smooth : float\n", - " Smoothing value used by ``dice_loss_from_logits``.\n", - " dna_pos_weight : torch.Tensor\n", - " Registered buffer containing the BCE positive-class weight. It is\n", - " moved automatically with the module across CPU and GPU devices.\n", - "\n", - " \"\"\"\n", - "\n", - " def __init__(\n", - " self,\n", - " dna_pos_weight: float = 1.0,\n", - " dna_loss_weight: float = 1.0,\n", - " cross_loss_weight: float = 0.10,\n", - " cross_pos_weight: float = 20.0,\n", - " dice_smooth: float = 1.0,\n", - " ):\n", - " \"\"\"Initialize the combined DNA and crossing loss.\n", - "\n", - " Parameters\n", - " ----------\n", - " dna_pos_weight : float, default=1.0\n", - " Positive-class weight for DNA pixels in the BCE component.\n", - " dna_loss_weight : float, default=1.0\n", - " Weight applied to the combined BCE-Dice DNA loss.\n", - " cross_loss_weight : float, default=0.10\n", - " Weight applied to the crossing MSE loss.\n", - " cross_pos_weight : float, default=20.0\n", - " Positive-class weight for crossing pixels in the MSE component.\n", - " dice_smooth : float, default=1.0\n", - " Smoothing constant used in the Dice loss.\n", - "\n", - " \"\"\"\n", - "\n", - " super().__init__()\n", - " self.dna_loss_weight = float(dna_loss_weight)\n", - " self.cross_loss_weight = float(cross_loss_weight)\n", - " self.dice_smooth = float(dice_smooth)\n", - " self.cross_pos_weight = float(cross_pos_weight)\n", - " pos_weight = torch.tensor(float(dna_pos_weight))\n", - " self.register_buffer(\"dna_pos_weight\", pos_weight)\n", - "\n", - " def forward(\n", - " self,\n", - " pred: torch.Tensor,\n", - " target: torch.Tensor,\n", - " ) -> torch.Tensor:\n", - " \"\"\"Return the weighted sum of DNA and crossing losses.\n", - "\n", - " Parameters\n", - " ----------\n", - " pred : torch.Tensor\n", - " Model output tensor with shape ``(B, 2, H, W)``. Channel 0 is\n", - " interpreted as DNA logits, and channel 1 is interpreted as\n", - " crossing logits.\n", - " target : torch.Tensor\n", - " Target tensor with shape ``(B, 2, H, W)``. Channel 0 should\n", - " contain the DNA mask, and channel 1 should contain the\n", - " crossing target.\n", - "\n", - " Returns\n", - " -------\n", - " torch.Tensor\n", - " Scalar loss equal to the weighted DNA BCE-Dice loss plus the\n", - " weighted crossing MSE loss.\n", - "\n", - " \"\"\"\n", - "\n", - " dna_logits = pred[:, 0:1]\n", - " cross_logits = pred[:, 1:2]\n", - " target_dna = target[:, 0:1]\n", - " target_cross = target[:, 1:2]\n", - " pos_weight = self.dna_pos_weight.to(pred.device)\n", - "\n", - " bce = F.binary_cross_entropy_with_logits(\n", - " dna_logits,\n", - " target_dna,\n", - " pos_weight=pos_weight,\n", - " )\n", - " dice = dice_loss_from_logits(\n", - " dna_logits,\n", - " target_dna,\n", - " smooth=self.dice_smooth,\n", - " )\n", - " dna_loss = 0.5 * bce + 0.5 * dice\n", - "\n", - " cross_prob = torch.sigmoid(cross_logits)\n", - " cross_weight = 1.0 + self.cross_pos_weight * target_cross\n", - " cross_error = torch.square(cross_prob - target_cross)\n", - " cross_loss = torch.mean(cross_weight * cross_error)\n", - "\n", - " return (\n", - " self.dna_loss_weight * dna_loss\n", - " + self.cross_loss_weight * cross_loss\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "HSGpfLYkOsSP", - "metadata": { - "id": "HSGpfLYkOsSP" - }, - "outputs": [], - "source": [ - "import torch\n", - "import torchmetrics\n", - "\n", - "\n", - "class DNADiceMetric(torchmetrics.Metric):\n", - " \"\"\"Compute DNA Dice score for the DNA output channel.\n", - "\n", - " This metric expects the model prediction to have two channels, where\n", - " channel 0 contains DNA logits. The target is also expected to have two\n", - " channels, where channel 0 contains the DNA mask.\n", - " \"\"\"\n", - "\n", - " full_state_update = False\n", - "\n", - " def __init__(self, smooth: float = 1.0):\n", - " \"\"\"Initialize the accumulated Dice statistics.\"\"\"\n", - " super().__init__()\n", - " self.smooth = float(smooth)\n", - "\n", - " self.add_state(\n", - " \"intersection\",\n", - " default=torch.tensor(0.0),\n", - " dist_reduce_fx=\"sum\",\n", - " )\n", - " self.add_state(\n", - " \"pred_sum\",\n", - " default=torch.tensor(0.0),\n", - " dist_reduce_fx=\"sum\",\n", - " )\n", - " self.add_state(\n", - " \"target_sum\",\n", - " default=torch.tensor(0.0),\n", - " dist_reduce_fx=\"sum\",\n", - " )\n", - "\n", - " def update(\n", - " self,\n", - " preds: torch.Tensor,\n", - " target: torch.Tensor,\n", - " ) -> None:\n", - " \"\"\"Update Dice statistics for one batch.\"\"\"\n", - " pred_dna = torch.sigmoid(preds[:, 0:1])\n", - " pred_dna = (pred_dna > 0.5).float()\n", - " target_dna = target[:, 0:1].float()\n", - "\n", - " self.intersection += torch.sum(pred_dna * target_dna)\n", - " self.pred_sum += torch.sum(pred_dna)\n", - " self.target_sum += torch.sum(target_dna)\n", - "\n", - " def compute(self) -> torch.Tensor:\n", - " \"\"\"Return the accumulated DNA Dice score.\"\"\"\n", - " numerator = 2.0 * self.intersection + self.smooth\n", - " denominator = self.pred_sum + self.target_sum + self.smooth\n", - "\n", - " return numerator / denominator" - ] - }, - { - "cell_type": "markdown", - "id": "aKsZcCVFEQud", - "metadata": { - "id": "aKsZcCVFEQud" - }, - "source": [ - "...and now we build the U-net..." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "MAhbZR8VhLPN", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "MAhbZR8VhLPN", - "outputId": "897528a3-c438-4440-abbc-9c0f607aa476" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Regressor(\n", - " (loss): DNACrossingLoss()\n", - " (optimizer): Adam[Adam](lr=0.001)\n", - " (train_metrics): MetricCollection(\n", - " (DNADiceMetric): DNADiceMetric(),\n", - " prefix=train\n", - " )\n", - " (val_metrics): MetricCollection(\n", - " (DNADiceMetric): DNADiceMetric(),\n", - " prefix=val\n", - " )\n", - " (test_metrics): MetricCollection(\n", - " (DNADiceMetric): DNADiceMetric(),\n", - " prefix=test\n", - " )\n", - " (model): UNet2d(\n", - " (encoder): ConvolutionalEncoder2d(\n", - " (blocks): LayerList(\n", - " (0): Conv2dBlock(\n", - " (layer): Conv2d(1, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", - " (activation): ReLU()\n", - " )\n", - " (1): Conv2dBlock(\n", - " (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", - " (layer): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", - " (activation): ReLU()\n", - " )\n", - " (2): Conv2dBlock(\n", - " (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", - " (layer): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", - " (activation): ReLU()\n", - " )\n", - " (3): Conv2dBlock(\n", - " (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", - " (layer): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", - " (activation): ReLU()\n", - " )\n", - " )\n", - " (postprocess): Identity()\n", - " )\n", - " (bottleneck): ConvolutionalNeuralNetwork(\n", - " (blocks): LayerList(\n", - " (0): Conv2dBlock(\n", - " (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", - " (layer): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", - " (activation): ReLU()\n", - " (upsample): ConvTranspose2d(128, 128, kernel_size=(2, 2), stride=(2, 2))\n", - " )\n", - " )\n", - " )\n", - " (decoder): ConvolutionalDecoder2d(\n", - " (blocks): LayerList(\n", - " (0): Conv2dBlock(\n", - " (layer): Conv2d(256, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", - " (activation): ReLU()\n", - " (upsample): ConvTranspose2d(64, 64, kernel_size=(2, 2), stride=(2, 2))\n", - " )\n", - " (1): Conv2dBlock(\n", - " (layer): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", - " (activation): ReLU()\n", - " (upsample): ConvTranspose2d(32, 32, kernel_size=(2, 2), stride=(2, 2))\n", - " )\n", - " (2): Conv2dBlock(\n", - " (layer): Conv2d(64, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", - " (activation): ReLU()\n", - " (upsample): ConvTranspose2d(16, 16, kernel_size=(2, 2), stride=(2, 2))\n", - " )\n", - " (3): Conv2dBlock(\n", - " (layer): Conv2d(32, 2, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", - " (activation): Identity()\n", - " )\n", - " )\n", - " (preprocess): Identity()\n", - " )\n", - " (skip): Cat()\n", - " )\n", - ")\n" - ] - } - ], - "source": [ - "unet = dl.UNet2d(\n", - " in_channels=int(MODEL_CFG['in_channels']),\n", - " channels=list(MODEL_CFG['channels']),\n", - " out_channels=int(MODEL_CFG['out_channels']),\n", - " skip=dl.Cat(),\n", - ")\n", - "\n", - "loss_fn = DNACrossingLoss(\n", - " dna_pos_weight=float(TRAIN_CFG['dna_pos_weight']),\n", - " dna_loss_weight=float(TRAIN_CFG['dna_loss_weight']),\n", - " cross_loss_weight=float(TRAIN_CFG['cross_loss_weight']),\n", - " cross_pos_weight=float(TRAIN_CFG['cross_pos_weight']),\n", - " dice_smooth=float(TRAIN_CFG['dice_smooth']),\n", - ")\n", - "dna_dice_metric = DNADiceMetric(\n", - " smooth=float(TRAIN_CFG[\"dice_smooth\"]),\n", - ")\n", - "unet_template = dl.Regressor(\n", - " model=unet,\n", - " loss=loss_fn,\n", - " metrics=[dna_dice_metric],\n", - " optimizer=dl.Adam(lr=float(TRAIN_CFG['lr'])),\n", - ")\n", - "\n", - "unet_app = unet_template.create()\n", - "print(unet_app)" - ] - }, - { - "cell_type": "markdown", - "id": "ZJ3x8tyFhLPN", - "metadata": { - "id": "ZJ3x8tyFhLPN" - }, - "source": [ - "### Train and validate" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "WDMgtIjNhLPN", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 420, - "referenced_widgets": [ - "8b28746752804efb9514a943d1eaaa40", - "719c2567f6c143f2bd88659fdbc158fb", - "4d504ee7c6074c64960523a855043fbc", - "b0a7821cc80b4d3085d0e3ed5722edd5", - "a90137b5afbb4831a319bd707ae66e55", - "7e8401965c3e4bce8c7c03f927e647b7", - "2b88126853b94cf085854107c124e754", - "ad94f07de5fd480c95d444bf89488537", - "fa210271474f4e82bb4d087e1ffeee4f", - "3a5610b41c5f49d78c2e89e23006cfd9", - "b9787a3252ca42b2a28072694afa7def", - "6daeec99a0ec4247b33fcc5424cdf2b1", - "3f8d2f2e30e54ea9ac57deca09cb34c8", - "084e9fa8a9924883ab4de7f6ff398d69", - "2ce720e250ef4bcc986904febc125b48", - "6a703a473224472f9f300236fc25bbe1", - "2902a8dadce1454491f29a01b6655cd3", - "3515df2d16e14a0284f605d63a48240e", - "140d409c39384bd8a39f55c3e7964c15", - "9a367b91d3fb40699363c94d40a21c7c", - "fc0b3426a46844028503ab46da1230fe", - "48f5b787955e41189e698f9f842d0523", - "c88525bd6bf54f718d16f5e7b2c8a438", - "043020ee46b04b0e849aa065eb1688e6", - "51a977e26e3246c0bb2f6e079a06a7bc", - "d4614ca1e2ee41e3a78be809c911e5a7", - "56399d46ad8b44ed8ed0adf329893522", - "7c8de7d0ad144b64bbfff2d0851c9ff2", - "5a20ac379047420483e2e3c281846da8", - "174d67b232ac40d695cb15665959ac0c", - "8a991636ec0d4514973402ce7942f200", - "e8f6d51de5214b58938e06faacf9e90f", - "c76e8e95ff844324b72e1ae2a040b673", - "3cc511d5ba384c10aa8d0d285ae9bc73", - "44500e4704f14a2ba6523013f2f237cb", - "cd2246e275ab4283aea5036a3c083cc3", - "1ba0dee7653247c8b6008c8c60dd40bd", - "fe23ff3e550a48de82471507e913f733", - "44930c49f41248f38f21e9d23941a1b3", - "4140dfc3649f489dbdb41c85525ea599", - "5d738cc2fe5447cb89f343a31554e050", - "daaac23228ea45da98b5c3819047daf2", - "3b4b83b841ab45bb9a19e08f52bfc887", - "6f6933d25b4147a288c1142f8aa49e24", - "4f64f33ec76545669aad6cad0532bf52", - "fe72db6203cc472695e2217021d84b33", - "a4a766bb527240aca3846cb63d9f1e1b", - "682e08c8af3247b8b01a31a113920e4f", - "904dd3a3be60473c91575ed0105bec04", - "966280e648174531853430b876c96b3e", - "80b7e2aa713a45ca9c2bf8eae7d6bb4d", - "6f5f7d72f10c42f2a13a4e330cd1d96d", - "c65cc31b212940c09f11ceb11c222ef4", - "c33091d26af94d4f849426d89604efc6", - "bd210a7aa7724c048560040debfbd7f6", - "07fd460123374011924050488957dfb9", - "fdd0ef85a11e431c8b9584622aa675f0", - "e2f90203e06442c88ac36903ea85f8e7", - "719b5325829f44caa738198d8d8919e2", - "851f40556b6545f1b2e8b2c49d1f3a24", - "3389a58f19334452a8a25dbe5e19f09a", - "afbf370d7070420baad9e7ce8b643456", - "962668142d9b497db0704cbc10129a80", - "3c85353efe9b47888787857596cb1741", - "2e608130a04c4799993b4ec2f0027f79", - "2c50e0b4586140f89b5c932f0924d24a", - "425cdf165e3549f592d2c869829a5cfc", - "d911964788894e79855e0ae47953103a", - "bb4da1ba8c2c47e084597c70e2441a44", - "4d3fad88182241c99d755adf8e5bbb77", - "efa4351f438740ebb3b555206fe96b6e", - "66a4a0681ee44eff8f045b7a385cd1a2", - "6a5a24e536314b55952f3ee2d8719970", - "4a405964924f4527bc988f1679002ea2", - "b8ff4c15bd8b404d8eba17d813f5a423", - "8e6caa11df7d40c880506ce1587d3080", - "03d29d4401344338a1bc1e840b8a8208", - "40ce8ac2ba224beb9d1cebb9295eae2c", - "b5ae1f24f1144a99bbae2c07ab050537", - "2c4a4a15fc154209857e5bc221d4a60b", - "7b6afd64da3f49c48f76feb8b75e54dd", - "604c401384d042eebd72651c36e9b3e5", - "cb153aa133b14ab08dfa44caeeb6b81e", - "1119633b9b7f45bcb9274237898ae999", - "8e84599c746a4d149d3f8930f2fab49d", - "9d7149c5a5174b5da388a5898036e8af", - "d93a2657edec4e23a50f067465192ee6", - "561247266aca4a06a29ca8d77d5390f1", - "23d930a463d04ebbac79f8ada451c1af", - "945010c321a84e41828d564ccd6cab17", - "f65b58b468a442fa9eeef48cccb9164f", - "2fa51f1fbb8b41359089e64ea3d9e709", - "84d2ca2125194162937cd60d202efee3", - "58034176a80143809a8dfc91a9a3aff3", - "556e1708cb714b7ca1f24dbcc30845cb", - "cb3e60255a18440b8bd26c6682520e63", - "0b1024f20aaa459aabd611e80ae46e53", - "4671ae95c7024ac9aef90bde31b1cd5a", - "54a4b9d97f1f4908871c6410b0372c9d", - "ebd8e5f5fc36423e854f3eb3d01a3ccb", - "4526a155d76542528b553180e2c9f107", - "43ad8d40f2104267a64d02c8a4735f42", - "f0d35a683ffe4f61a9ed609a837b0cc7", - "201b24c9f69c4af18145260bb4ecb762", - "81671ac2f73b48669e505f454b013dca", - "a289a2fa75f04aae936662ccd032d70f", - "3250e51e0ed34ad9a8a81354466952bd", - "709b15f575e2439b914968dce170619a", - "e3308390869847b1a8c4123b5350f9d7", - "17bdd1be5491412cacbecb7feeae2fc7", - "678a690a7ede408fbd504364e0515db1", - "705032b0be3741eb8d9f4cc9d3842feb", - "5729ea76ec2b4c9eb3f5143f3e5b0a60", - "5c6215db50ab462388024533bc764d6c", - "475556f9d2db4569b985192b4648a9bb", - "138d51e2eee64063b8347d75eb3002e5", - "385582d247594701bf07ea19abcc6961", - "db7f36c1229c472bbfca23cfc260f4c5", - "77babc7cce66414b87aa437610eb4bd5", - "b6f83849585749c9851b2eb021d99f97", - "2f65e0c84ad0488589d9099d8857e813", - "827ab09eb5244faaa2bb7737bc38a662", - "0d0222a098a24c4db6e99d2e3f0921ad", - "59e61b3b77174b06a86e04d5ebda5703", - "8874086714df499886c05cfaf1202ff1", - "215a7a11baf44b5782096bc13d88a0be", - "7501155baee5472f9140ac1e04845f75", - "33c6b24328c341e190273d1ab5d3917a", - "8a3f0120a932480fabd5df4bab19b4ee", - "bfe5ecfb0f4c402ca61d4c401882c29f", - "d8dea74096e64878b237c0a851aac991", - "e34bdd70106343a5b8612b488b0113f6", - "1c9744b2ed434eedba77eb04cabdf204", - "61c1424c837a411d91e1e361e2f663fb", - "5d24e35625b1440fb3e0254d16762b22", - "995eb88c1ce5422b83ec25f99a059bb0", - "3e98332b532745d3bbcac8801aae2a31", - "4cb23d2da234483fab7b0d292aae77d6", - "cfddec8a651f495397214b49f9b8091d", - "80f20c8f2c1948c69cd779e36f7066c7", - "5ae95da99ca04dd899c2e10cfcb1a4b7", - "308d296e4c784d5e88bf05985a0a6273", - "996b3a00f07045c48d80011f2f6bf295", - "38a1154b2af840c2bfa56f98637ee08d", - "56e7ad0645874b6697ee7d6058041638", - "8ce63facf77441cf8015139500564c5d", - "c740afa60993457d959de43a861e200d", - "f3ab972f1ab14fd69d87e7a9af800aaf", - "917afa78da954d1e8ad09dd4cf9f4202", - "0ae94f04037447acb216044112f9175b", - "43989ff4ef934577b920e58f7458cc0a", - "e813e4725c4a43adba6363b551246f61", - "84deef98024b48efb3f18fae1ee3dffc", - "a1b8f183134e41c3969882b651876c05", - "7861c5c2fdc54fcd8f3cfb26be5f4dc5", - "47aded72d1e2424f97dc3426fbff540f", - "ebbf3193c2ea4b7d98d8504af04bb7e1", - "c9899780726f453b8ef79792b92576cc", - "6e2e3c6c871342c883141e0314353e37", - "2b2610ec8b884911a15455ebb9f8852b", - "5429aadaaaaa4767942be28932e6e09a", - "d61e750471554974ae9b07a81dce6932", - "7d6da8d8ded148e7958e1b747424828a", - "efa1c19e95504fbfb3130ce5d2f9e06e", - "74f2bc8b9aee4fc9986ed0e6d833bab3", - "94de6e1f0dc54520b8bf96bec4599f9a", - "6bfbb82616da41e6aa398500f81eb7b5", - "6390e224619346a8af81a12030c7fb38", - "0f6cde3fd35f4bf7ad1e8b22a2915a29", - "277bc910427c41c09786efadfb15e973", - "030b37cea4ba414db5fae6384ed6cdb6", - "f73f08cd498a47eaa01b6ee3e0a9d288", - "72299ab304f54db1a02a56f0d4c0ec54", - "aa0d6cf2f28040c19305a9704740ec23", - "c3ae2ada559f4a77834b47afeb954e2e", - "1ff6d20727704f89a15e7f62263b7c03", - "f12bed710be1411f8e30968f4e09554e", - "e6cf9c9bda7b4d37a0ea40d0565bdc25", - "7cb62ceb722f4d38b9c5d80b32b0841a", - "9c0cb0386434437681770e99b0db0744", - "413006fb9d2e453abf39cdd4b91caa75", - "d4ca8a1f229148a880d420776312aff2", - "7eaa8bd25f384c9a8ba7fb6faed6b3f7", - "ec1864db512149518a1b0cbbbab057d6", - "bbfe385d70f84c3fa7c22e04a4faa8a3", - "6a9cab5ce8ff43b3a57c47931d4c1cc8", - "bf19184bcfd74fd6a01f0e791d4b1bb9", - "ffae1f6825c045178ae33dea1d805c87", - "fb12c181ee7d42c7aa4256347200bea4", - "bc93eb10d7f44b559d17c6b5c6cb93b7", - "209c4f3f80e14a969afb2b32c7216dbd", - "2345ab7c9cfb4dc295f34c54579408fb", - "c67eb73d43c449f2801750558f4a521d", - "c0c48b257aa04dd4883d496f59eb1d82", - "1088c60e62f64798b702028799231729", - "6b89e0a40f934cd78aa670de2bbc7158", - "12a635899c1643788e566ba87ab1723c", - "9504247d6ca649aea2ef4ad828f523a6", - "72823355de9044eba020e56ffe2d3865", - "87dd9bcece474721b57d651815d4115a", - "80202dea9db64ae7987c220a85a7dcac", - "6178e85c32c64115bd3105cd74efed18", - "0eaa81e3e1d443c387792ee6e64fd1b6", - "5c49200354514c20bdb71fedbcf634a2", - "9546adf443cb47cea6d50a2c4f24fd85", - "ce568ae8b1bd4bc28cea074e0a295ef0", - "d2232ad66e614f79aa31dacb583eac7e", - "4fb03babee474f98bc3f153b930c3973", - "22ad0c58d4a94b469e15b425c20edb60", - "671faaa6260e4b6687d39e69951d7764", - "37b3cad147f74c4397a16ca6883ba98a", - "f977f92cd00040b79d1370265c355470", - "7ee7fbcfa28f4708b85d4721945a34c6", - "2426adb29a43459895b1f5192654b6ec", - "ba5d1cdcc089456b81b50d8e9c033bfa", - "4a34d533b9374b60aec1d1b6e8935014", - "d794297461194c3d98cbf0f27d30b67a", - "27807cb739b249a59a6e0d9d317414df", - "0b0b8dfdf0054425b83e8a4994acc8fc", - "7ec6252e85764215b7b94d323aeba6d6", - "67da59c080324e948eeb07890d5ee9da", - "73a668df55a54615ba5bffc804be35af", - "e80004eab2b54b4eafcfab7c2dec94d9", - "2701cb8cf0b64ae0b15efe9c0e32dd01", - "bb444ac91bbf4b91883b5ccd40b6bd41", - "9cce801e24c147cea6eb4861b5a55987", - "885eba97a8bd4006ae9cc9994724c6a8", - "1f272fa725454bb3bf529bdf2604eb12", - "279a78ac51154592a3d288be64dc843f", - "2bc4378549914bd4a48aaf0a677ddc41", - "8cc548cea0c247d4ae5ab1eeed9cc475", - "4190b291524948279b199476f5533730", - "6438832fe5474201965419106035e40e", - "eb045b2ed03c4f31b6e30f8c54f5e34a", - "14dbde6953364c5c87d9469c49959066", - "30eef8822a3645bda76c1de7866f2d7a", - "3314d1f00dd74034bc28143b99bef726", - "7e095acd45294cd499418a6dc525ac28", - "4e0c287d06814086b4c1b478fb11dfe5", - "451d8508824949d0ae06c2be42504f7b", - "3de0b3794ad54c45b7c019cfd285a95e", - "e2362e5efae7467b8e58786955739072", - "d2b1934184984f6da6e2a9f0cc091e2e", - "f0c011f3be21460f8b128ff280d68808", - "712feb908f5045e39b75f7123bb7dbf6", - "a1478fa6b5ce4aa9bd0ccee4c50602f5", - "7a37a6630f874ef1af76b2c89f6fe269", - "5f8819ebd06e4a3f8dab4a84855019dd", - "103b137bb36a47fcbbbe9b0c3f2e2a20", - "50ac65735b464186a73dd287df8bdb90", - "8ad023a1d4414a33bf73eaf801cbd3c4", - "57a0365d6e264988a9f8340c13cb32ac", - "03e87b2770764a44b0fb60c69940fa8a", - "5d116e6c9d944632a0bb3667425ce1fa", - "2e4b3d2637214494a1e3144a63f6b2d8", - "48eed094358c4c33a1fec51e83ad1449", - "331f64d00dc547d7928e433cd4bffde1", - "b2f473ff0fdf49698f439d63ad6e6954", - "27960ebdc9b64bfc854a283e2907e11b", - "29150d9e2a414583870407fcd56e0287", - "faa2148c3d1849708c7c61edd90e1291", - "7ce09c539e7e43239b274b2951847b4e", - "8f0006a1050e49819bfecf9817429c51", - "5f21fb315ce049e49d37e44aa6adf375", - "7a860c9a51884bc28dbc95be3a5eff52", - "743dd24c3e314c0590a187f1166bc10e", - "6348038c38224d04af7bf57abedabec9", - "e77db813dca54e869bea4a928040769a", - "101ae0ce1af94c45a5f01989c271074d", - "da1ce1311a7a49a9b83bd4b6edeb6f98", - "6e8070d424684b45bc2d2452edfd1ca6", - "96a3c2562f2e4d97b8e11bfea7092ad1", - "e51e2fae2577476eb17a5589654e4146", - "b65b184f71e5418299c8c15f2982e874", - "49e5341ae44b43bc887609a461efc80b", - "4a14a6ec2d3348dcbc9875ec7af4e928", - "53f2f6f68bce41c08df12776081ea727", - "a752a853b6da4c9a867cbc4c356a5f86", - "9f59240c317a4919bced1fea1302825f", - "17e293d4e9764a2c9336651c5186597c", - "ece37dfc7f7846089b7ae9f620da5590", - "6849f7fa0d6f41ab9c8a3fafadd166b1", - "cf90653728a544029afdf0d285db1b71", - "14dfa39560914f5e9269e122d47adcfa", - "2f1edcd918d446e5bf1c0b48d8ea442f", - "9fe43efc7832435a91ce56ba8c6b0e71", - "cfc3eed1a714480ea5c25697e9cfb760", - "3083d2e358de4e00a24910dbff9d83d0", - "ed779a27748c4413b93ddae88e3b6847", - "4fd7a055897d495da333b612468f50d3", - "ff128da02ac640b8815356d193efb837", - "5d21a03a00ed4c4e8772c1b2aa49036e", - "c09e5bcfc73a436e8ab8bce80a2f066c", - "091cf2b9b40b414e9463f51088f93be9", - "bd24262a245b4a8fa786bc8a172e64d0", - "2247bf9c5e134d28ac140fa9947cbadd", - "7b312daa8c8d4f4693a43fb24c9167a7", - "a227c49da5464a3db3817b29583b19a2", - "f45de29667c64d98a6d84e5fc642c631", - "cc1285bdc1a74576929e696b39cdff32", - "c11a0b4153bb41229b54f2c316e49fb6", - "e0b7aafcb493493eb7cc38dcc2e7e790", - "88123fd47960496e989711120607b605", - "f0607bf5f1644ca2950b93029d08cdef", - "54afe3c681fd4869b5cc34d9aa410881", - "31a5f2acf0774510a8f94b1dd0c3611f", - "6c3a98e141ef41ebac5033241e901a0a", - "176b8cafeae846b08bd905108c49c187", - "f88883a2b4ba433692a7d91e76cb64c2", - "170c77c2f53347eba458933ccc9fade6", - "b673982fde464818902b9d9188682521", - "631e42e29fa24b01bdf65a52c5a3789e", - "c47cbc67f63d4664a525f45cb9be802f", - "4aec1986363b4a899ff12c1670eb99d4", - "119a284ae3b940bea7c0fb71473cac17", - "036e4baeb0f84146aad777ed9987dbdb", - "f148afd0ea3a4625a3600fc67c3693ff", - "134eb7ee8cc64f68be7803f5d10e415c", - "a136e3374ce04534a06061f743d710d5", - "0e2ae121d9514519b6e71da13bc5b3eb", - "19bb84dc4f074dd2b18a994ce05b6cb2", - "28908c600d00452f9a15cc76962fbc65", - "800b1826eb8a4fac98702973a4329c9b", - "aee41a66745047fba6a396645a7b8ad2", - "561482bb8bda448b8ac9f924ebac2c49", - "b224a2ff47304317af4868ac6370ffbd", - "819b4436cf3548f29ac4d5ed3fb45eb8", - "4cc3497b5dca4bb092237b8dbef8cb8f", - "c8f695256a574888af49e942ff0d53ea", - "783b37e7224247b5ad69a3a9fe83cab0", - "6513da4ffafb4d01b5c487ac7cf931ae", - "b40b9defd0e54112a478434d87f3d37c", - "afa45e41b7894012966afdceddbdcef9", - "203d55b28e7b4c12940f1af7e0fb5fcd", - "907e7eeceda44049b47167d5772392d8", - "2968cd77eaac49d09fc69844d62d533e", - "24107da359a7483c83160459daa1091c", - "a7e7f2bcb26848f09f12b01bc1820c98", - "77a3ae393cd54d0f90573d4b2f962c6c", - "03c4214a21fe476fa585f7bc35d5db34", - "12efe63c7cbb426a9cbf135ca597c637", - "a6b98b78fc9c4106be98cc9c76420e45", - "08050b72b51745a0bb4a6db7eee67474", - "51de3b840a3344c8b1131aa08d0c48af", - "fa8df0bc1a3d4b469ee5f3d25a0f92d2", - "e2a9cc1c6dea443ca1aa1841fa3fce5a", - "5d09e24e29e94a9493293cb44f2f05ed", - "e8d243e979184d43b46d66e8eaeec7fc", - "18d30486f46544ba947954cad0897d53", - "5887ca685a454f069902494c857eff62", - "2fa9970eb2344e038499dc2a08791f13", - "48333bff75384cf7886c81ca1e3f0056", - "a3e103155f8048798c0ac10a88493730", - "e4fa28df40184fef85979ecf49eb0227", - "8543f611eeb1412bad6d60f9188daa72", - "d5cfe8ba6de44341a3a93ad3a4453def", - "0a5c47146e3841d7826ec9f9ebc4ebaf", - "29dad287ff434262917e99d4abe87e22", - "b068791a98704c6e8ab258319dad8263", - "899083680c9848b4879aebd89f447fc8", - "cd7c7e091fc24d328e550c0c49fc3a8a", - "021e47894cca42c88d89421b56dfb919", - "3cc8a7fba51942de9e82264e548c62a5", - "dce8d86194e345cc9fe8792d1bd457e8", - "3eff3edded23414db81879b4c2f6f5b8", - "3c8c8708d15d43af8d9a86b752f019c9", - "d00f6502d78f48a6afd47fef76056b0c", - "ab2dcf296209485aa2bdcc204e782715", - "789c4051b78e427c80d9505e4144f46a", - "90f631a62ce44f6db314bd9cf1451074", - "9f1ee508f1b0446797118ce36c038fd4", - "ac11c98a0f884eabb0111353c01533ed", - "8cba9c6709e5454ea15349dc42cfe0cd", - "f9b7ccdfa2be41a7a8f7a7a64699b47a", - "bbc25d75785846ebadf149ac3bc399e2", - "c24c9d09c1ff4c4497c11e087cb74601", - "eecb9deb211c43c7b99d28a147d64574", - "f909105afa944e23a3bd7448050b8e24", - "dd7333bf31cb4da9b0cbe872d706569b", - "5c2bdf30acb64fde97964052bf1158ea", - "c42e9afe917b4d238b64c8dae423a08c", - "a52384c27ba84d7ea578c9b8973931f7", - "2a928efa36a84ee6b7ddd50505f8bed9", - "07b7b5dcb848469e8f53eeedf1bc6b33", - "3a923915a02341c8adda26e702a58649", - "ea77318badcd47a48dc6631fc4b34705", - "bc896c2b5a674b58a8f4297c86335e6c", - "524439135fb54e3ba86f5ace4eb06338", - "8e6a75869f2f4ac5a531530b43b40718", - "5e923969e34848c6851b2b03c7b41841", - "6cb7b43df77648d39950587fb4839546", - "3ac04713cef64e8cb11d8a4d405726c4", - "b0133d98440d4496995d89a6c3d24a9c", - "81bbb203f78c4e9ca03bae7163d04459", - "02deb853ae5945098b5c1598e0782932", - "3f9b1734cae4441e8e9842e786e3a666", - "2f58726958f648ebbadb90e95bbdfdc6", - "e9add7d8e3534205a85161a1dd8c0561", - "c732b4b99e5e43de98eba24ea9330b8c", - "0a6bc2c7f6cc4af7868ec259cf8e2d10", - "b462c001fb154c4794053ce3126dd644", - "22da81f202af4f88849537be607e9ee3", - "eac934f0739245f6ab3366ce113ca5ea", - "a2a5801a03eb4c488bea54a303de8aa8", - "f58e5e4225644425a58df21cc258b2e9", - "a3c33f5a9a25492aa0e775ed7afe26f2", - "1ae29602ef9a44abb3182f797198a743", - "e8eead01a58840588b916d34bac88da9", - "890891d40cbd42c19ac36100fd39b3c4", - "4ba6608f281b443094cd1a057fc56edf", - "e56dddf291fc4a87a8abcf35deb3ada4", - "3593ff33dc6a422691e37ae61708a66b", - "7144eb829e304795b3a54362a2d3308d", - "3c9251f3f32a49189ed62cf12908b655", - "f110be5d117b49ffb8f696ebeb44fd54", - "9ebee1344386470abd6ecb7c73c114e8", - "a66f018d98b043a69b1877d53170c040", - "22d5c7797b224ceeab780e907164a7f8", - "203ae02e062e45ed9a3f521242fdeff7", - "ae7f89fa88e4492e8d47b8c7592c1271", - "5c9b296e4e2248bd80b763abfa0d3aa9", - "d0e3de0c45944a3ca22baafdb51612b6", - "7be149c51b0b4709b53a97c054ee154d", - "53514d6c6a5747c781da5d5731076fa3", - "6113dfc521c64c89abc5c0a20499381f", - "67091d0ab8274792a1ee046e7d5ba315", - "4c5db6fbb19943c19b6a91c9ebb72227", - "ec0d2f874c0b4d90b70dab8a364a7177", - "0aed735a0bef4bca94cc0f83fc6bb741", - "b560e10add5d49dc875984178fb6c6bb", - "586ca83e63894831b02c18cd6d50ac67", - "49a0cb79625a46dc9241a2707a27e52a", - "67c16e3db25c47b581acbe130118fbb9", - "b0f4c8fb387e489b942f9f0d6ae7d8ea", - "246b3248809140ce93eb13901bed3892", - "31eb075cdf584cfa829bc3f119aa9244", - "8e7e13c148344fcbbe81f9a38bda633b", - "1af74cb9bbf24e2e805ca966acbe0907", - "1c19b3d200d14671994983a2b480d525", - "9fe0c115193a46c2839b7dba4930ab81", - "3cde40f339394878b928ec180b8e4e64", - "d63a1a9bacb04337b03301301ceed042", - "33e6c841c0154edbb81d53bf5de15b9a", - "975b6c14f7204bd39dcfc6af693c85b1", - "6df28ba2fc2d46cc8b51f0d80c8ba25d", - "7ef0a9a688f447a98ef9341b72b1a6ba", - "5671f7eaab934f108a1202ab876c0da9", - "07729109119944f9bfdf4bfb15f68e0b", - "4d6169d06e3f420abdfe10140b2f1752", - "43130a49034c46deb88430a97b67b772", - "2e3cf4039bd7412889f96e0f5074d17b", - "3885a42d96a44dfcbd3448c4f32a356f", - "5911fd23e2c840d9a59cadc4fcdb797d", - "0ea178dd6d3540bd87787328120fd36b", - "db212b22656948d9a190fc4a1a22d139", - "7b33cc704c9140f195ac96f687d735e9", - "7ae860cacde943d9b40ce530f3de23e7", - "2d4feafdf81144ac9ec7610c6bd7bec5", - "eb974dbc33d040f9b178b3a77dd40596", - "a73eb569400d41ff84133f7c31197f10", - "94b0542bd9a24f47829d80d75e9e6caf", - "3ee03c10f050486a953717e911d126c8", - "79bee0ed60c84ba5aea9f9f0b1314031", - "a097f30c0c204cb9924d6f6bdd709cbe", - "4e4b06c04fb9400b9a89aacaa0b1926a", - "1d903dbd3c9c4f059e5f539cb8d49e80", - "d83d719827dc4cf18fd6b4be1a013b48", - "cc5789103b634ea091fe10e89a0fa387", - "1c7fe430ec1147afabbc3b8f2733595f", - "0c1de1c66eed49ad826796f167c875fe", - "9313d0d4d0794c448c119cb081eeefd8", - "5a8d30cc9ab2422094515bd3fa829cf0", - "691e3d84fe9642f592bc6621df965af6", - "6e366f2178ab48519debac50a89d8b9f", - "8819541346574b2f9b8ad66a924f66a0", - "484a5d3a19474d23821c279f602e067d", - "6daa75d66b5e4ae9a248ca81f9a973c4", - "d43d30e849b048c5b038c0ea28051a29", - "14907f787b0b4e1da4a252d16f1928f9", - "a0ab8aa511344baf879297df64c2f9fc", - "dbb3626925144fbb9366336171f85a41", - "eadafdb5fc3d4f3b84df9ae41c5854aa", - "cdeb0f7de79e4f06b4c76d92d276cb20", - "72d85446467f44819931d0fc1ef388ca", - "73622e0503054ee4aa0a851c245eb607", - "0eca4509b4a94446874ac1614104642b", - "1a6d7e044bf341b88232922836650fef", - "d5ef045581f049caa9d79f10907e526a", - "02349ea7bced4c8186933cd0134487f2", - "c91100e69a0e4320a37a979b0586d808", - "691fc75d0196480c94281c9f8c4e4444", - "3c1323bad0314e4fa563e498e7bda9f6", - "ff75dc1b2fbd42dd804840d7a2e6a5e3", - "6942c1a729a14fb7823c10209797414f", - "0d91c6de914d46af8891967ed2d6775a", - "97cdd8befbe4449f9a005e3b33848f00", - "8d6de7a9be714081a8e1369deb51dee6", - "56ddb3c87b764bdc96a118235ed5c1e1", - "f5bdab9255224de7ae62b4c83169c022", - "68fdb591245f4e2d9df83514d7d5e6bb", - "256268cbec374eae90521d3b14c86c9f", - "918c0123e33f453fa046d906e31191f7", - "12f90753525d4938bd9ccdd3affdf222", - "bedfd3bf09594024adfbcc6c76b3d120", - "8f76fcea6a0a45d1af4d5e4985ababda", - "fea61d5d08c349faae33df0f4b6cbbb9", - "4a8debce9ea84992af1a53c9aaa7470d", - "199b2ba5fee04882ae0d71a1f06c8c29", - "10bb79a6159545a9a8e1f0a2e1a2cf03", - "93470f3024cc4db09420bcf82df30ed0", - "b9b5f84e0ad04dfdaa801aae0759b7c8", - "a240a470cabe4ec5aba95cbec336c87f", - "7ae73c7bbf9f4dc7bc28d31f17f6d5d0", - "b30a5a9d17284e919da9c824022469c0", - "07f20a998e834aa681080aa17e2cef27", - "412e24ef862f483093195c1c2dad9700", - "333b116b292148699bda35d8da71f3a8", - "56b57990ab094da3accd27ee807e9a92", - "680893a87c164913972e227461e4853c", - "175aa4436adf4ba699b550ec31f13f8c", - "e4e08a2301f6407eb5cc13c15102efe6", - "5b2c06adca494ad8b235031e32e3d769", - "cf72bf7126a24a8281cfc4ff0dac558b", - "59b6ed718ae547519a7520bd0ba8cff6", - "7bea23ddd64f4b229e869423fca4a3fa", - "3e535346524042d1b6d156a73faf2fc9", - "2ee030af4e5541489a20050aad8efce5", - "d169d623177b4f73a73034c7f0b50b5d", - "da6176592b274c47aaeecc2428c76c9c", - "273f928c594e471290863f82079d9180", - "43ce5cc7a3794a9faed7a053c984636e", - "c171ca6ce6c342e3a2b554f0a1e96946", - "df60c4135a444a448b0d200ecdd01e43", - "acbd9aa0859342e19a0e0ce928d6ad05", - "5ce8d4f4ca734748adf31e8a5328a430", - "5955d67a815e42cbbc391fec4784bea1", - "83fa2586801d4cbdac47384f78e906ba", - "6469faa7ce30401c8406ace5479d0744", - "55ebce6aedaf44569ebe813c11d86db0", - "31a8648ed6174b3ea0d6cca904f8018c", - "4a9dadfe582049babf7e91c7d956de55", - "f62028910b1a4e299444705e7795058c", - "26668e33d9dd4d67b39da870b6b26df8", - "9bda89af8a87453894b70a571544af1e", - "7b10ca1619e948dd91248c7ec8b075ef", - "eabdb0f39f1f43cf8f5e37b2abfc279f", - "5d11defaa1624b83a8a47e4745a13d7a", - "5d57d4c3e3a24cac8a8ab228b199ca22", - "921a4b00691a4346b04ee18dda85fe9c", - "0b36b8a64f4846b58a5a73ffb5076123", - "071b189c1ef64856808a5430060c4308", - "52db1d1561db4f5ca9b881ff55320251", - "bf97514daefb48869a318e5e617483a1", - "6e5f2583b8cc4cc8a1218f2c2bec6297", - "60102f86fd2742cdb8c73a720c558b21", - "92b11b42862d464fa908abaeb6a2e437", - "a1003fa3bcb249b886cfc6a7fb50f3b7", - "d0fe8f14840146df9fc769f2ffc6f103", - "1dc882f2764548e1a1103da0a7d4052a", - "449171807ad14b55876489b49b09bcd8", - "eccaed078ac547328383e1fb8c8422bd", - "61bdef04eaff450ca8d552b7ebc67533", - "08147947751240079f5d4fc1ebb3d2a8", - "656ec0e3fc91481bb1fbd3aec5c9f007", - "f3c46fae7ba04122b9ea6721d3fd59f9", - "65af6aa005304854b289c94d562ee42c", - "22c7d5d6518943ae9bad7733aa3aeb6b", - "6f152e50ae2e433aa01bf9820764022c", - "9a70f8e5d1b345bda0c4aecf39e26596", - "5ee267ba68f04f27a4d44ac895c28be4", - "b1eabe6afaab4879b4e60b75a13c53f2", - "561adb0dc1c943e6ac7734d9d214f35a" - ] - }, - "id": "WDMgtIjNhLPN", - "outputId": "e24ad80e-70ee-48f5-b77a-aea87ded2688" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Python platform: Windows-10-10.0.26200-SP0\n", - "Training accelerator: CUDA GPU: NVIDIA RTX PRO 4000 Blackwell Generation Laptop GPU\n", - "Training precision: 16-mixed\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\Users\\xdutpr\\OneDrive - Chalmers\\AFM_pipeline\\dna-afm.venv\\lib\\site-packages\\lightning\\pytorch\\utilities\\model_summary\\model_summary.py:242: Precision 16-mixed is not supported by the model summary. Estimated model size in MB will not be accurate. Using 32 bits instead.\n" - ] - }, - { - "data": { - "text/html": [ - "
┏━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━┳━━━━━━━┓\n",
-              "┃   ┃ Name          ┃ Type             ┃ Params ┃ Mode  ┃ FLOPs ┃\n",
-              "┡━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━╇━━━━━━━┩\n",
-              "│ 0 │ loss          │ DNACrossingLoss  │      0 │ train │     0 │\n",
-              "│ 1 │ train_metrics │ MetricCollection │      0 │ train │     0 │\n",
-              "│ 2 │ val_metrics   │ MetricCollection │      0 │ train │     0 │\n",
-              "│ 3 │ test_metrics  │ MetricCollection │      0 │ train │     0 │\n",
-              "│ 4 │ model         │ UNet2d           │  526 K │ train │     0 │\n",
-              "│ 5 │ optimizer     │ Adam             │      0 │ train │     0 │\n",
-              "└───┴───────────────┴──────────────────┴────────┴───────┴───────┘\n",
-              "
\n" - ], - "text/plain": [ - "┏━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━┳━━━━━━━┓\n", - "┃\u001b[1;35m \u001b[0m\u001b[1;35m \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mName \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mType \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mParams\u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mMode \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mFLOPs\u001b[0m\u001b[1;35m \u001b[0m┃\n", - "┡━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━╇━━━━━━━┩\n", - "│\u001b[2m \u001b[0m\u001b[2m0\u001b[0m\u001b[2m \u001b[0m│ loss │ DNACrossingLoss │ 0 │ train │ 0 │\n", - "│\u001b[2m \u001b[0m\u001b[2m1\u001b[0m\u001b[2m \u001b[0m│ train_metrics │ MetricCollection │ 0 │ train │ 0 │\n", - "│\u001b[2m \u001b[0m\u001b[2m2\u001b[0m\u001b[2m \u001b[0m│ val_metrics │ MetricCollection │ 0 │ train │ 0 │\n", - "│\u001b[2m \u001b[0m\u001b[2m3\u001b[0m\u001b[2m \u001b[0m│ test_metrics │ MetricCollection │ 0 │ train │ 0 │\n", - "│\u001b[2m \u001b[0m\u001b[2m4\u001b[0m\u001b[2m \u001b[0m│ model │ UNet2d │ 526 K │ train │ 0 │\n", - "│\u001b[2m \u001b[0m\u001b[2m5\u001b[0m\u001b[2m \u001b[0m│ optimizer │ Adam │ 0 │ train │ 0 │\n", - "└───┴───────────────┴──────────────────┴────────┴───────┴───────┘\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
Trainable params: 526 K                                                                                            \n",
-              "Non-trainable params: 0                                                                                            \n",
-              "Total params: 526 K                                                                                                \n",
-              "Total estimated model params size (MB): 2                                                                          \n",
-              "Modules in train mode: 53                                                                                          \n",
-              "Modules in eval mode: 0                                                                                            \n",
-              "Total FLOPs: 0                                                                                                     \n",
-              "
\n" - ], - "text/plain": [ - "\u001b[1mTrainable params\u001b[0m: 526 K \n", - "\u001b[1mNon-trainable params\u001b[0m: 0 \n", - "\u001b[1mTotal params\u001b[0m: 526 K \n", - "\u001b[1mTotal estimated model params size (MB)\u001b[0m: 2 \n", - "\u001b[1mModules in train mode\u001b[0m: 53 \n", - "\u001b[1mModules in eval mode\u001b[0m: 0 \n", - "\u001b[1mTotal FLOPs\u001b[0m: 0 \n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Sanity Checking DataLoader 0: 0%| | 0/2 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from pathlib import Path\n", - "\n", - "import pandas as pd\n", - "\n", - "def get_latest_metrics_path(trainer) -> Path:\n", - " \"\"\"Return the metrics CSV path from the active trainer logger.\n", - "\n", - " Parameters\n", - " ----------\n", - " trainer : lightning.pytorch.Trainer\n", - " Trainer used for the most recent training run.\n", - "\n", - " Returns\n", - " -------\n", - " Path\n", - " Path to the CSV metrics file written by the trainer logger.\n", - "\n", - " Raises\n", - " ------\n", - " RuntimeError\n", - " If the trainer does not have a logger with a log directory.\n", - " FileNotFoundError\n", - " If the expected metrics CSV file does not exist.\n", - " \"\"\"\n", - " if trainer.logger is None:\n", - " raise RuntimeError(\"The trainer does not have a logger.\")\n", - "\n", - " log_dir = getattr(trainer.logger, \"log_dir\", None)\n", - "\n", - " if log_dir is None:\n", - " raise RuntimeError(\n", - " \"The trainer logger does not expose a log_dir attribute.\"\n", - " )\n", - "\n", - " metrics_path = Path(log_dir) / \"metrics.csv\"\n", - "\n", - " if not metrics_path.exists():\n", - " raise FileNotFoundError(\n", - " \"Could not find the metrics CSV for the latest run.\\n\"\n", - " f\"Expected path: {metrics_path}\"\n", - " )\n", - "\n", - " return metrics_path\n", - "\n", - "\n", - "def plot_training_metrics(metrics):\n", - " \"\"\"Plot total loss and DNA Dice curves by epoch.\n", - "\n", - " Parameters\n", - " ----------\n", - " metrics : pandas.DataFrame or dict\n", - " Training metrics loaded from the CSV logger. The object should\n", - " contain an ``epoch`` column and logged metric columns such as\n", - " ``train_loss_epoch``, ``val_loss_epoch``,\n", - " ``train_dna_dice_epoch``, and ``val_dna_dice_epoch``.\n", - "\n", - " \"\"\"\n", - "\n", - " if not hasattr(metrics, \"columns\"):\n", - " metrics = pd.DataFrame(metrics)\n", - "\n", - " metrics = metrics.copy()\n", - " metrics = metrics.sort_values(\"epoch\")\n", - " metrics = metrics.groupby(\"epoch\", as_index=False).last()\n", - "\n", - " fig, axs = plt.subplots(2, figsize=(8, 6), sharex=True)\n", - "\n", - " axs[0].plot(\n", - " metrics[\"epoch\"],\n", - " metrics[\"train_loss_epoch\"],\n", - " label=\"Train loss\",\n", - " )\n", - " axs[0].plot(\n", - " metrics[\"epoch\"],\n", - " metrics[\"val_loss_epoch\"],\n", - " label=\"Validation loss\",\n", - " )\n", - " axs[0].set_ylabel(\"Loss\")\n", - " axs[0].set_title(\"Training and validation loss\")\n", - " axs[0].legend()\n", - "\n", - " dice_columns = [\n", - " col for col in metrics.columns\n", - " if \"dice\" in col.lower()\n", - " ]\n", - "\n", - " if dice_columns:\n", - " for col in dice_columns:\n", - " axs[1].plot(\n", - " metrics[\"epoch\"],\n", - " metrics[col],\n", - " label=col,\n", - " )\n", - " axs[1].legend()\n", - " else:\n", - " axs[1].text(\n", - " 0.5,\n", - " 0.5,\n", - " \"No DNA Dice metric was logged.\",\n", - " ha=\"center\",\n", - " va=\"center\",\n", - " transform=axs[1].transAxes,\n", - " )\n", - "\n", - " axs[1].set_xlabel(\"Epoch\")\n", - " axs[1].set_ylabel(\"DNA Dice\")\n", - " axs[1].set_title(\"DNA Dice\")\n", - "\n", - " plt.tight_layout()\n", - " plt.show()\n", - "\n", - "metrics_path = get_latest_metrics_path(trainer)\n", - "print(\"Loading metrics from:\", metrics_path)\n", - "\n", - "metrics = pd.read_csv(metrics_path)\n", - "plot_training_metrics(metrics)" - ] - }, - { - "cell_type": "markdown", - "id": "naPFGb1-hLPN", - "metadata": { - "id": "naPFGb1-hLPN" - }, - "source": [ - "### DNA-focused validation metrics" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "URzcLeLdhLPN", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "URzcLeLdhLPN", - "outputId": "1d822fba-242e-4e1e-acda-774eab0de379" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "validation {'loss': 0.05329109877347946, 'dna_dice': 0.9196728706359864, 'dna_iou': 0.8513635277748108, 'cross_mse': 0.00067206178791821}\n" - ] - } - ], - "source": [ - "def dice_score_from_prob(\n", - " prob: torch.Tensor,\n", - " target: torch.Tensor,\n", - " threshold: float = 0.5,\n", - " eps: float = 1e-6,\n", - ") -> torch.Tensor:\n", - " \"\"\"Hard Dice score for binary DNA masks.\"\"\"\n", - "\n", - " pred = (prob >= threshold).float()\n", - " dims = tuple(range(1, pred.ndim))\n", - " inter = torch.sum(pred * target, dim=dims)\n", - " denom = torch.sum(pred, dim=dims) + torch.sum(target, dim=dims)\n", - " return ((2.0 * inter + eps) / (denom + eps)).mean()\n", - "\n", - "\n", - "def iou_score_from_prob(\n", - " prob: torch.Tensor,\n", - " target: torch.Tensor,\n", - " threshold: float = 0.5,\n", - " eps: float = 1e-6,\n", - ") -> torch.Tensor:\n", - " \"\"\"Hard IoU score for binary DNA masks.\"\"\"\n", - "\n", - " pred = (prob >= threshold).float()\n", - " dims = tuple(range(1, pred.ndim))\n", - " inter = torch.sum(pred * target, dim=dims)\n", - " union = torch.sum((pred + target) > 0, dim=dims)\n", - " return ((inter + eps) / (union + eps)).mean()\n", - "\n", - "\n", - "def evaluate_loader(model, loader, stage: str) -> dict[str, float]:\n", - " \"\"\"Evaluate DNA Dice, DNA IoU, and crossing MSE.\"\"\"\n", - "\n", - " model.eval()\n", - " device = next(model.parameters()).device\n", - " totals = dict(loss=0.0, dna_dice=0.0, dna_iou=0.0)\n", - " totals['cross_mse'] = 0.0\n", - " count = 0\n", - "\n", - " with torch.no_grad():\n", - " for image, target in loader:\n", - " image = image.to(device)\n", - " target = target.to(device)\n", - " pred = model(image)\n", - " loss = loss_fn(pred, target)\n", - " dna_prob = torch.sigmoid(pred[:, 0:1])\n", - " cross_prob = torch.sigmoid(pred[:, 1:2])\n", - " target_dna = target[:, 0:1]\n", - " target_cross = target[:, 1:2]\n", - " batch_size = int(image.shape[0])\n", - "\n", - " totals['loss'] += float(loss) * batch_size\n", - " totals['dna_dice'] += float(\n", - " dice_score_from_prob(dna_prob, target_dna)\n", - " ) * batch_size\n", - " totals['dna_iou'] += float(\n", - " iou_score_from_prob(dna_prob, target_dna)\n", - " ) * batch_size\n", - " totals['cross_mse'] += float(\n", - " F.mse_loss(cross_prob, target_cross)\n", - " ) * batch_size\n", - " count += batch_size\n", - "\n", - " metrics = {key: value / max(count, 1) for key, value in totals.items()}\n", - " print(stage, metrics)\n", - " return metrics\n", - "\n", - "\n", - "val_metrics = evaluate_loader(unet_app, val_loader, 'validation')" - ] - }, - { - "cell_type": "markdown", - "id": "qzz07wo9hLPN", - "metadata": { - "id": "qzz07wo9hLPN" - }, - "source": [ - "### Optional prediction preview" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "THN5kDG3hLPN", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 259 - }, - "id": "THN5kDG3hLPN", - "outputId": "7ac3caf4-24dd-4bb3-e693-16bf65b1c901" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "DNA pred min/max: 8.557251484372534e-28 1.0\n", - "Cross pred min/max: 3.894112587943255e-09 0.6136244535446167\n", - "Cross target min/max: 0.0 0.9888139367103577\n" - ] - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "def show_prediction(\n", - " batch: tuple[torch.Tensor, ...],\n", - " model: torch.nn.Module,\n", - " index: int = 1,\n", - ") -> None:\n", - " \"\"\"Visualize the model's predictions against ground truth for one sample.\n", - "\n", - " This function takes a batch of data, performs an evaluation-mode forward\n", - " pass using the provided model, and plots the image, the DNA segmentation\n", - " (target vs. prediction), and the crossing detection (target vs. prediction)\n", - " masks.\n", - "\n", - " Parameters\n", - " ----------\n", - " batch : tuple[torch.Tensor, ...]\n", - " A tuple containing (images, targets).\n", - " - images: Tensor of shape (B, C, H, W).\n", - " - targets: Tensor of shape (B, 2, H, W) containing DNA and crossing\n", - " masks.\n", - " model : torch.nn.Module\n", - " The neural network (e.g., U-Net or ResU-Net) used for inference.\n", - " index : int, optional\n", - " The index of the specific sample within the batch to visualize.\n", - " Defaults to 1.\n", - "\n", - " Returns\n", - " -------\n", - " None\n", - " The function displays a Matplotlib figure and does not return a value.\n", - "\n", - " Notes\n", - " -----\n", - " The function automatically handles device placement (CPU/GPU) by checking\n", - " the model's parameters and applies a sigmoid activation to the model\n", - " output to transform logits into probabilities.\n", - "\n", - " \"\"\"\n", - "\n", - " image, target = batch\n", - " model.eval()\n", - " device = next(model.parameters()).device\n", - "\n", - " with torch.no_grad():\n", - " pred = model(image.to(device))\n", - " dna_prob = torch.sigmoid(pred[:, 0:1]).cpu()\n", - " cross_prob = torch.sigmoid(pred[:, 1:2]).cpu()\n", - "\n", - " panels = [\n", - " image[index, 0].cpu(),\n", - " target[index, 0].cpu(),\n", - " dna_prob[index, 0],\n", - " target[index, 1].cpu(),\n", - " cross_prob[index, 0],\n", - " ]\n", - "\n", - " titles = [\n", - " \"image\",\n", - " \"dna target\",\n", - " \"dna pred\",\n", - " \"cross target\",\n", - " \"cross pred\",\n", - " ]\n", - "\n", - " fig, axes = plt.subplots(1, len(panels), figsize=(15, 3))\n", - "\n", - " for ax, panel, title in zip(axes, panels, titles):\n", - " ax.imshow(panel, cmap=\"gray\", vmin=0.0, vmax=1.0)\n", - " ax.set_title(title)\n", - " ax.axis(\"off\")\n", - "\n", - " plt.show()\n", - "\n", - " print(\"DNA pred min/max:\", float(dna_prob.min()), float(dna_prob.max()))\n", - " print(\n", - " \"Cross pred min/max:\",\n", - " float(cross_prob.min()),\n", - " float(cross_prob.max()),\n", - " )\n", - " print(\n", - " \"Cross target min/max:\",\n", - " float(target[:, 1:2].min()),\n", - " float(target[:, 1:2].max()),\n", - " )\n", - "\n", - "\n", - "batch = next(iter(val_loader))\n", - "show_prediction(batch, unet_app)" - ] - }, - { - "cell_type": "markdown", - "id": "cc_My3GrTgFm", - "metadata": { - "id": "cc_My3GrTgFm" - }, - "source": [ - "# 17. Evaluation on real data" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3YLZtTblTfuf", - "metadata": { - "id": "3YLZtTblTfuf" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using existing real test data root: all_data\n" - ] - } - ], - "source": [ - "from pathlib import Path\n", - "import zipfile\n", - "# Set this to a zip file containing the real data, if available.\n", - "TEST_ZIP_PATH = Path(\"data_picoz.zip\") \n", - "# Set this to an existing test data root if you have existing test data.\n", - "TEST_ROOT = Path(\"all_data\")\n", - "\n", - "\n", - "if TEST_ROOT.exists():\n", - " print(\"Using existing real test data root:\", TEST_ROOT)\n", - "\n", - "else:\n", - " if not TEST_ZIP_PATH.exists():\n", - " raise FileNotFoundError(\n", - " \"Set TEST_ROOT to an existing test-data folder, or set \"\n", - " \"TEST_ZIP_PATH to an uploaded real test zip file.\\n\"\n", - " f\"Current TEST_ROOT: {TEST_ROOT}\\n\"\n", - " f\"Current TEST_ZIP_PATH: {TEST_ZIP_PATH}\"\n", - " )\n", - "\n", - " TEST_ROOT.mkdir(parents=True, exist_ok=True)\n", - "\n", - " with zipfile.ZipFile(TEST_ZIP_PATH, \"r\") as zip_ref:\n", - " zip_ref.extractall(TEST_ROOT)\n", - "\n", - " print(\"Extracted real test data to:\", TEST_ROOT)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "2pCKb3H7fK_c", - "metadata": { - "id": "2pCKb3H7fK_c" - }, - "outputs": [], - "source": [ - "TEST_EXTENSIONS = {\".png\",\".jpg\",\".jpeg\",\".tif\",\".tiff\",\".npy\"}\n", - "\n", - "IMAGE_KEYWORDS = (\"image\",\"images\",\"img\",\"afm\",\"raw\")\n", - "\n", - "DNA_MASK_KEYWORDS = (\"mask\",\"masks\",\"label\",\"labels\",\"seg\",\n", - " \"segmentation\")\n", - "\n", - "CROSS_MASK_KEYWORDS = (\"cross\",\"crossing\",\"crossings\")\n", - "\n", - "\n", - "def is_data_file(path: Path) -> bool:\n", - " \"\"\"Return whether a path has a supported image or array suffix.\n", - "\n", - " Parameters\n", - " ----------\n", - " path : Path\n", - " Candidate file path.\n", - "\n", - " Returns\n", - " -------\n", - " bool\n", - " True if the file suffix is supported.\n", - "\n", - " \"\"\"\n", - "\n", - " return path.is_file() and path.suffix.lower() in TEST_EXTENSIONS\n", - "\n", - "\n", - "def path_text(path: Path) -> str:\n", - " \"\"\"Return a lower-case path string for keyword matching.\n", - "\n", - " Parameters\n", - " ----------\n", - " path : Path\n", - " File path to convert.\n", - "\n", - " Returns\n", - " -------\n", - " str\n", - " Lower-case path string using forward slashes.\n", - "\n", - " \"\"\"\n", - "\n", - " return path.as_posix().lower()\n", - "\n", - "\n", - "def contains_any(text: str, keywords: tuple[str, ...]) -> bool:\n", - " \"\"\"Return whether any keyword is present in text.\n", - "\n", - " Parameters\n", - " ----------\n", - " text : str\n", - " Text to search.\n", - " keywords : tuple[str, ...]\n", - " Keywords to look for.\n", - "\n", - " Returns\n", - " -------\n", - " bool\n", - " True if any keyword is present.\n", - "\n", - " \"\"\"\n", - "\n", - " return any(keyword in text for keyword in keywords)\n", - "\n", - "\n", - "def normalized_stem(path: Path) -> str:\n", - " \"\"\"Return a comparable stem with common prefixes removed.\n", - "\n", - " Parameters\n", - " ----------\n", - " path : Path\n", - " File path whose stem should be normalized.\n", - "\n", - " Returns\n", - " -------\n", - " str\n", - " Normalized stem used for matching images to masks.\n", - "\n", - " \"\"\"\n", - "\n", - " stem = path.stem.lower()\n", - "\n", - " prefixes = (\n", - " \"img_\",\n", - " \"image_\",\n", - " \"afm_\",\n", - " \"raw_\",\n", - " \"dna_\",\n", - " \"mask_\",\n", - " \"label_\",\n", - " \"seg_\",\n", - " \"cross_\",\n", - " \"crossing_\",\n", - " )\n", - "\n", - " changed = True\n", - " while changed:\n", - " changed = False\n", - " for prefix in prefixes:\n", - " if stem.startswith(prefix):\n", - " stem = stem[len(prefix):]\n", - " changed = True\n", - "\n", - " return stem\n", - "\n", - "\n", - "def collect_test_files(root: Path) -> tuple[list[Path], list[Path], list[Path]]:\n", - " \"\"\"Collect candidate image, DNA mask, and crossing files.\n", - "\n", - " Parameters\n", - " ----------\n", - " root : Path\n", - " Root directory containing the extracted real test data.\n", - "\n", - " Returns\n", - " -------\n", - " tuple[list[Path], list[Path], list[Path]]\n", - " Candidate image files, DNA mask files, and crossing mask files.\n", - " \"\"\"\n", - " image_files = []\n", - " dna_files = []\n", - " cross_files = []\n", - "\n", - " for path in root.rglob(\"*\"):\n", - " if not is_data_file(path):\n", - " continue\n", - "\n", - " text = path_text(path)\n", - " has_cross = contains_any(text, CROSS_MASK_KEYWORDS)\n", - " has_dna = contains_any(text, DNA_MASK_KEYWORDS)\n", - " has_image = contains_any(text, IMAGE_KEYWORDS)\n", - "\n", - " if has_cross:\n", - " cross_files.append(path)\n", - " elif has_dna:\n", - " dna_files.append(path)\n", - " elif has_image:\n", - " image_files.append(path)\n", - "\n", - " if not image_files:\n", - " for path in root.rglob(\"*\"):\n", - " if is_data_file(path):\n", - " text = path_text(path)\n", - " if not contains_any(text, DNA_MASK_KEYWORDS):\n", - " if not contains_any(text, CROSS_MASK_KEYWORDS):\n", - " image_files.append(path)\n", - "\n", - " return image_files, dna_files, cross_files\n", - "\n", - "\n", - "def index_by_stem(paths: list[Path]) -> dict[str, Path]:\n", - " \"\"\"Index file paths by normalized stem.\n", - "\n", - " Parameters\n", - " ----------\n", - " paths : list[Path]\n", - " Paths to index.\n", - "\n", - " Returns\n", - " -------\n", - " dict[str, Path]\n", - " Mapping from normalized stem to path.\n", - " \"\"\"\n", - " output = {}\n", - "\n", - " for path in sorted(paths):\n", - " output.setdefault(normalized_stem(path), path)\n", - "\n", - " return output" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "73XVRC_zfqJ5", - "metadata": { - "id": "73XVRC_zfqJ5" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Real test samples: 107\n", - "First real test row: {'id': '0', 'image_path': 'all_data\\\\image_0.npy', 'dna_path': 'all_data\\\\mask_0.npy', 'cross_path': ''}\n" - ] - } - ], - "source": [ - "def build_real_test_records(root: Path) -> list[dict[str, str]]:\n", - " \"\"\"Build DeepTrack source records for a real test dataset.\n", - "\n", - " Parameters\n", - " ----------\n", - " root : Path\n", - " Root directory containing extracted real test data.\n", - "\n", - " Returns\n", - " -------\n", - " list[dict[str, str]]\n", - " Records compatible with ``build_pipeline`` and\n", - " ``DeepTrackSourceDataset``.\n", - " \"\"\"\n", - " image_files, dna_files, cross_files = collect_test_files(root)\n", - "\n", - " dna_by_stem = index_by_stem(dna_files)\n", - " cross_by_stem = index_by_stem(cross_files)\n", - " records = []\n", - " unmatched = []\n", - "\n", - " for image_path in sorted(image_files):\n", - " stem = normalized_stem(image_path)\n", - " dna_path = dna_by_stem.get(stem)\n", - " cross_path = cross_by_stem.get(stem, \"\")\n", - "\n", - " if dna_path is None:\n", - " unmatched.append(str(image_path))\n", - " continue\n", - "\n", - " records.append(\n", - " dict(\n", - " id=stem,\n", - " image_path=str(image_path),\n", - " dna_path=str(dna_path),\n", - " cross_path=str(cross_path) if cross_path else \"\",\n", - " )\n", - " )\n", - "\n", - " if unmatched:\n", - " print(\"Images without matched DNA masks:\", len(unmatched))\n", - " print(\"\\n\".join(unmatched[:10]))\n", - "\n", - " if not records:\n", - " raise RuntimeError(\n", - " \"No matched real test image/mask pairs were found. \"\n", - " \"Check folder names and file stems.\"\n", - " )\n", - "\n", - " return records\n", - "\n", - "\n", - "test_records = build_real_test_records(TEST_ROOT)\n", - "test_source = dt.sources.Source(samples=test_records)\n", - "\n", - "print(\"Real test samples:\", len(test_source))\n", - "print(\"First real test row:\", test_records[0])" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "bjQzPfplfseS", - "metadata": { - "id": "bjQzPfplfseS" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Created test_loader with 107 samples.\n", - "real_test {'loss': 1.2244887020543358, 'dna_dice': 0.7941006962384018, 'dna_iou': 0.6712675289572957, 'cross_mse': 0.009400565220721972}\n" - ] - }, - { - "data": { - "text/plain": [ - "{'loss': 1.2244887020543358,\n", - " 'dna_dice': 0.7941006962384018,\n", - " 'dna_iou': 0.6712675289572957,\n", - " 'cross_mse': 0.009400565220721972}" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "test_dataset = DeepTrackSourceDataset(\n", - " test_source,\n", - " TARGET_SIZE,\n", - " augment=False,\n", - ")\n", - "\n", - "test_loader = dl.DataLoader(\n", - " test_dataset,\n", - " batch_size=int(TRAIN_CFG[\"batch_size\"]),\n", - " shuffle=False,\n", - " num_workers=0,\n", - " persistent_workers=False,\n", - ")\n", - "\n", - "print(f\"Created test_loader with {len(test_dataset)} samples.\")\n", - "\n", - "test_metrics = evaluate_loader(\n", - " unet_app,\n", - " test_loader,\n", - " \"real_test\",\n", - ")\n", - "\n", - "test_metrics" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "OKGD106Dfyxi", - "metadata": { - "id": "OKGD106Dfyxi" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "DNA pred min/max: 5.786328443570148e-28 0.9999998807907104\n", - "Cross pred min/max: 3.463686892857254e-09 0.7061609029769897\n", - "Cross target min/max: 0.0 0.0\n" - ] - } - ], - "source": [ - "test_batch = next(iter(test_loader))\n", - "show_prediction(\n", - " test_batch,\n", - " unet_app,\n", - " index=1,\n", - ")" - ] - } - ], - "metadata": { - "accelerator": "GPU", - "colab": { - "gpuType": "T4", - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3", - "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.8" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "021e47894cca42c88d89421b56dfb919": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "02349ea7bced4c8186933cd0134487f2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "02deb853ae5945098b5c1598e0782932": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "030b37cea4ba414db5fae6384ed6cdb6": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "036e4baeb0f84146aad777ed9987dbdb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "03c4214a21fe476fa585f7bc35d5db34": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "03d29d4401344338a1bc1e840b8a8208": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "03e87b2770764a44b0fb60c69940fa8a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "043020ee46b04b0e849aa065eb1688e6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_7c8de7d0ad144b64bbfff2d0851c9ff2", - "placeholder": "​", - "style": "IPY_MODEL_5a20ac379047420483e2e3c281846da8", - "value": "Validation DataLoader 0: 100%" - } - }, - "071b189c1ef64856808a5430060c4308": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_52db1d1561db4f5ca9b881ff55320251", - "IPY_MODEL_bf97514daefb48869a318e5e617483a1", - "IPY_MODEL_6e5f2583b8cc4cc8a1218f2c2bec6297" - ], - "layout": "IPY_MODEL_60102f86fd2742cdb8c73a720c558b21" - } - }, - "07729109119944f9bfdf4bfb15f68e0b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "07b7b5dcb848469e8f53eeedf1bc6b33": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "07f20a998e834aa681080aa17e2cef27": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "07fd460123374011924050488957dfb9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_fdd0ef85a11e431c8b9584622aa675f0", - "IPY_MODEL_e2f90203e06442c88ac36903ea85f8e7", - "IPY_MODEL_719b5325829f44caa738198d8d8919e2" - ], - "layout": "IPY_MODEL_851f40556b6545f1b2e8b2c49d1f3a24" - } - }, - "08050b72b51745a0bb4a6db7eee67474": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_5d09e24e29e94a9493293cb44f2f05ed", - "placeholder": "​", - "style": "IPY_MODEL_e8d243e979184d43b46d66e8eaeec7fc", - "value": "Validation DataLoader 0: 100%" - } - }, - "08147947751240079f5d4fc1ebb3d2a8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_22c7d5d6518943ae9bad7733aa3aeb6b", - "placeholder": "​", - "style": "IPY_MODEL_6f152e50ae2e433aa01bf9820764022c", - "value": "Validation DataLoader 0: 100%" - } - }, - "084e9fa8a9924883ab4de7f6ff398d69": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_140d409c39384bd8a39f55c3e7964c15", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_9a367b91d3fb40699363c94d40a21c7c", - "value": 1 - } - }, - "091cf2b9b40b414e9463f51088f93be9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "0a5c47146e3841d7826ec9f9ebc4ebaf": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "0a6bc2c7f6cc4af7868ec259cf8e2d10": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_a3c33f5a9a25492aa0e775ed7afe26f2", - "placeholder": "​", - "style": "IPY_MODEL_1ae29602ef9a44abb3182f797198a743", - "value": " 3/3 [00:00<00:00, 23.27it/s]" - } - }, - "0ae94f04037447acb216044112f9175b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "0aed735a0bef4bca94cc0f83fc6bb741": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "0b0b8dfdf0054425b83e8a4994acc8fc": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "0b1024f20aaa459aabd611e80ae46e53": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "0b36b8a64f4846b58a5a73ffb5076123": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "0c1de1c66eed49ad826796f167c875fe": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "0d0222a098a24c4db6e99d2e3f0921ad": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_7501155baee5472f9140ac1e04845f75", - "placeholder": "​", - "style": "IPY_MODEL_33c6b24328c341e190273d1ab5d3917a", - "value": "Validation DataLoader 0: 100%" - } - }, - "0d91c6de914d46af8891967ed2d6775a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "0e2ae121d9514519b6e71da13bc5b3eb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_19bb84dc4f074dd2b18a994ce05b6cb2", - "IPY_MODEL_28908c600d00452f9a15cc76962fbc65", - "IPY_MODEL_800b1826eb8a4fac98702973a4329c9b" - ], - "layout": "IPY_MODEL_aee41a66745047fba6a396645a7b8ad2" - } - }, - "0ea178dd6d3540bd87787328120fd36b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_eb974dbc33d040f9b178b3a77dd40596", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_a73eb569400d41ff84133f7c31197f10", - "value": 1 - } - }, - "0eaa81e3e1d443c387792ee6e64fd1b6": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "0eca4509b4a94446874ac1614104642b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_c91100e69a0e4320a37a979b0586d808", - "placeholder": "​", - "style": "IPY_MODEL_691fc75d0196480c94281c9f8c4e4444", - "value": "Validation DataLoader 0: 100%" - } - }, - "0f6cde3fd35f4bf7ad1e8b22a2915a29": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_c3ae2ada559f4a77834b47afeb954e2e", - "placeholder": "​", - "style": "IPY_MODEL_1ff6d20727704f89a15e7f62263b7c03", - "value": " 3/3 [00:00<00:00, 22.62it/s]" - } - }, - "101ae0ce1af94c45a5f01989c271074d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "103b137bb36a47fcbbbe9b0c3f2e2a20": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "1088c60e62f64798b702028799231729": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "10bb79a6159545a9a8e1f0a2e1a2cf03": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_b30a5a9d17284e919da9c824022469c0", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_07f20a998e834aa681080aa17e2cef27", - "value": 1 - } - }, - "1119633b9b7f45bcb9274237898ae999": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "119a284ae3b940bea7c0fb71473cac17": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "12a635899c1643788e566ba87ab1723c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "12efe63c7cbb426a9cbf135ca597c637": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "12f90753525d4938bd9ccdd3affdf222": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "134eb7ee8cc64f68be7803f5d10e415c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "138d51e2eee64063b8347d75eb3002e5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "140d409c39384bd8a39f55c3e7964c15": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "14907f787b0b4e1da4a252d16f1928f9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "14dbde6953364c5c87d9469c49959066": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_3de0b3794ad54c45b7c019cfd285a95e", - "placeholder": "​", - "style": "IPY_MODEL_e2362e5efae7467b8e58786955739072", - "value": " 3/3 [00:00<00:00, 17.35it/s]" - } - }, - "14dfa39560914f5e9269e122d47adcfa": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "170c77c2f53347eba458933ccc9fade6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_4aec1986363b4a899ff12c1670eb99d4", - "placeholder": "​", - "style": "IPY_MODEL_119a284ae3b940bea7c0fb71473cac17", - "value": "Validation DataLoader 0: 100%" - } - }, - "174d67b232ac40d695cb15665959ac0c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "175aa4436adf4ba699b550ec31f13f8c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_7bea23ddd64f4b229e869423fca4a3fa", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_3e535346524042d1b6d156a73faf2fc9", - "value": 1 - } - }, - "176b8cafeae846b08bd905108c49c187": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "17bdd1be5491412cacbecb7feeae2fc7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "17e293d4e9764a2c9336651c5186597c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "18d30486f46544ba947954cad0897d53": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "199b2ba5fee04882ae0d71a1f06c8c29": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_a240a470cabe4ec5aba95cbec336c87f", - "placeholder": "​", - "style": "IPY_MODEL_7ae73c7bbf9f4dc7bc28d31f17f6d5d0", - "value": "Validation DataLoader 0: 100%" - } - }, - "19bb84dc4f074dd2b18a994ce05b6cb2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_561482bb8bda448b8ac9f924ebac2c49", - "placeholder": "​", - "style": "IPY_MODEL_b224a2ff47304317af4868ac6370ffbd", - "value": "Validation DataLoader 0: 100%" - } - }, - "1a6d7e044bf341b88232922836650fef": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_3c1323bad0314e4fa563e498e7bda9f6", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_ff75dc1b2fbd42dd804840d7a2e6a5e3", - "value": 1 - } - }, - "1ae29602ef9a44abb3182f797198a743": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "1af74cb9bbf24e2e805ca966acbe0907": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "1ba0dee7653247c8b6008c8c60dd40bd": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_3b4b83b841ab45bb9a19e08f52bfc887", - "placeholder": "​", - "style": "IPY_MODEL_6f6933d25b4147a288c1142f8aa49e24", - "value": " 3/3 [00:00<00:00, 18.34it/s]" - } - }, - "1c19b3d200d14671994983a2b480d525": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "1c7fe430ec1147afabbc3b8f2733595f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "1c9744b2ed434eedba77eb04cabdf204": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_61c1424c837a411d91e1e361e2f663fb", - "IPY_MODEL_5d24e35625b1440fb3e0254d16762b22", - "IPY_MODEL_995eb88c1ce5422b83ec25f99a059bb0" - ], - "layout": "IPY_MODEL_3e98332b532745d3bbcac8801aae2a31" - } - }, - "1d903dbd3c9c4f059e5f539cb8d49e80": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_5a8d30cc9ab2422094515bd3fa829cf0", - "placeholder": "​", - "style": "IPY_MODEL_691e3d84fe9642f592bc6621df965af6", - "value": " 3/3 [00:00<00:00, 21.83it/s]" - } - }, - "1dc882f2764548e1a1103da0a7d4052a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "1f272fa725454bb3bf529bdf2604eb12": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "1ff6d20727704f89a15e7f62263b7c03": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "201b24c9f69c4af18145260bb4ecb762": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "203ae02e062e45ed9a3f521242fdeff7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_ae7f89fa88e4492e8d47b8c7592c1271", - "IPY_MODEL_5c9b296e4e2248bd80b763abfa0d3aa9", - "IPY_MODEL_d0e3de0c45944a3ca22baafdb51612b6" - ], - "layout": "IPY_MODEL_7be149c51b0b4709b53a97c054ee154d" - } - }, - "203d55b28e7b4c12940f1af7e0fb5fcd": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_03c4214a21fe476fa585f7bc35d5db34", - "placeholder": "​", - "style": "IPY_MODEL_12efe63c7cbb426a9cbf135ca597c637", - "value": " 3/3 [00:00<00:00, 20.55it/s]" - } - }, - "209c4f3f80e14a969afb2b32c7216dbd": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_12a635899c1643788e566ba87ab1723c", - "placeholder": "​", - "style": "IPY_MODEL_9504247d6ca649aea2ef4ad828f523a6", - "value": " 3/3 [00:00<00:00, 23.69it/s]" - } - }, - "215a7a11baf44b5782096bc13d88a0be": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "2247bf9c5e134d28ac140fa9947cbadd": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "22ad0c58d4a94b469e15b425c20edb60": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "22c7d5d6518943ae9bad7733aa3aeb6b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "22d5c7797b224ceeab780e907164a7f8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "22da81f202af4f88849537be607e9ee3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2345ab7c9cfb4dc295f34c54579408fb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "23d930a463d04ebbac79f8ada451c1af": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_945010c321a84e41828d564ccd6cab17", - "IPY_MODEL_f65b58b468a442fa9eeef48cccb9164f", - "IPY_MODEL_2fa51f1fbb8b41359089e64ea3d9e709" - ], - "layout": "IPY_MODEL_84d2ca2125194162937cd60d202efee3" - } - }, - "24107da359a7483c83160459daa1091c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "2426adb29a43459895b1f5192654b6ec": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "246b3248809140ce93eb13901bed3892": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "256268cbec374eae90521d3b14c86c9f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "26668e33d9dd4d67b39da870b6b26df8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_921a4b00691a4346b04ee18dda85fe9c", - "placeholder": "​", - "style": "IPY_MODEL_0b36b8a64f4846b58a5a73ffb5076123", - "value": " 3/3 [00:00<00:00, 19.02it/s]" - } - }, - "2701cb8cf0b64ae0b15efe9c0e32dd01": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_2bc4378549914bd4a48aaf0a677ddc41", - "placeholder": "​", - "style": "IPY_MODEL_8cc548cea0c247d4ae5ab1eeed9cc475", - "value": " 3/3 [00:00<00:00, 22.08it/s]" - } - }, - "273f928c594e471290863f82079d9180": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_acbd9aa0859342e19a0e0ce928d6ad05", - "placeholder": "​", - "style": "IPY_MODEL_5ce8d4f4ca734748adf31e8a5328a430", - "value": "Validation DataLoader 0: 100%" - } - }, - "277bc910427c41c09786efadfb15e973": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "27807cb739b249a59a6e0d9d317414df": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "27960ebdc9b64bfc854a283e2907e11b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "279a78ac51154592a3d288be64dc843f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "28908c600d00452f9a15cc76962fbc65": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_819b4436cf3548f29ac4d5ed3fb45eb8", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_4cc3497b5dca4bb092237b8dbef8cb8f", - "value": 1 - } - }, - "2902a8dadce1454491f29a01b6655cd3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "29150d9e2a414583870407fcd56e0287": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "2968cd77eaac49d09fc69844d62d533e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "29dad287ff434262917e99d4abe87e22": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2a928efa36a84ee6b7ddd50505f8bed9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "2b2610ec8b884911a15455ebb9f8852b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2b88126853b94cf085854107c124e754": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "2bc4378549914bd4a48aaf0a677ddc41": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2c4a4a15fc154209857e5bc221d4a60b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_8e84599c746a4d149d3f8930f2fab49d", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_9d7149c5a5174b5da388a5898036e8af", - "value": 1 - } - }, - "2c50e0b4586140f89b5c932f0924d24a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "2ce720e250ef4bcc986904febc125b48": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_fc0b3426a46844028503ab46da1230fe", - "placeholder": "​", - "style": "IPY_MODEL_48f5b787955e41189e698f9f842d0523", - "value": " 10/10 [00:01<00:00,  7.44it/s, v_num=2, train_loss_step=0.0535, trainDNADiceMetric_step=0.915, val_loss_step=0.053, valDNADiceMetric_step=0.917, val_loss_epoch=0.0572, valDNADiceMetric_epoch=0.911, train_loss_epoch=0.0546, trainDNADiceMetric_epoch=0.915]" - } - }, - "2d4feafdf81144ac9ec7610c6bd7bec5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "2e3cf4039bd7412889f96e0f5074d17b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "2e4b3d2637214494a1e3144a63f6b2d8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_27960ebdc9b64bfc854a283e2907e11b", - "placeholder": "​", - "style": "IPY_MODEL_29150d9e2a414583870407fcd56e0287", - "value": "Validation DataLoader 0: 100%" - } - }, - "2e608130a04c4799993b4ec2f0027f79": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2ee030af4e5541489a20050aad8efce5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2f1edcd918d446e5bf1c0b48d8ea442f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2f58726958f648ebbadb90e95bbdfdc6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_e9add7d8e3534205a85161a1dd8c0561", - "IPY_MODEL_c732b4b99e5e43de98eba24ea9330b8c", - "IPY_MODEL_0a6bc2c7f6cc4af7868ec259cf8e2d10" - ], - "layout": "IPY_MODEL_b462c001fb154c4794053ce3126dd644" - } - }, - "2f65e0c84ad0488589d9099d8857e813": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "2fa51f1fbb8b41359089e64ea3d9e709": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_4671ae95c7024ac9aef90bde31b1cd5a", - "placeholder": "​", - "style": "IPY_MODEL_54a4b9d97f1f4908871c6410b0372c9d", - "value": " 3/3 [00:00<00:00, 20.21it/s]" - } - }, - "2fa9970eb2344e038499dc2a08791f13": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "3083d2e358de4e00a24910dbff9d83d0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_5d21a03a00ed4c4e8772c1b2aa49036e", - "placeholder": "​", - "style": "IPY_MODEL_c09e5bcfc73a436e8ab8bce80a2f066c", - "value": "Validation DataLoader 0: 100%" - } - }, - "308d296e4c784d5e88bf05985a0a6273": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "30eef8822a3645bda76c1de7866f2d7a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "31a5f2acf0774510a8f94b1dd0c3611f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "31a8648ed6174b3ea0d6cca904f8018c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_4a9dadfe582049babf7e91c7d956de55", - "IPY_MODEL_f62028910b1a4e299444705e7795058c", - "IPY_MODEL_26668e33d9dd4d67b39da870b6b26df8" - ], - "layout": "IPY_MODEL_9bda89af8a87453894b70a571544af1e" - } - }, - "31eb075cdf584cfa829bc3f119aa9244": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "3250e51e0ed34ad9a8a81354466952bd": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "3314d1f00dd74034bc28143b99bef726": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "331f64d00dc547d7928e433cd4bffde1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_8f0006a1050e49819bfecf9817429c51", - "placeholder": "​", - "style": "IPY_MODEL_5f21fb315ce049e49d37e44aa6adf375", - "value": " 3/3 [00:00<00:00, 22.61it/s]" - } - }, - "333b116b292148699bda35d8da71f3a8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "3389a58f19334452a8a25dbe5e19f09a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "33c6b24328c341e190273d1ab5d3917a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "33e6c841c0154edbb81d53bf5de15b9a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_07729109119944f9bfdf4bfb15f68e0b", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_4d6169d06e3f420abdfe10140b2f1752", - "value": 1 - } - }, - "3515df2d16e14a0284f605d63a48240e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "3593ff33dc6a422691e37ae61708a66b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "37b3cad147f74c4397a16ca6883ba98a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_ba5d1cdcc089456b81b50d8e9c033bfa", - "placeholder": "​", - "style": "IPY_MODEL_4a34d533b9374b60aec1d1b6e8935014", - "value": "Validation DataLoader 0: 100%" - } - }, - "385582d247594701bf07ea19abcc6961": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "3885a42d96a44dfcbd3448c4f32a356f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_5911fd23e2c840d9a59cadc4fcdb797d", - "IPY_MODEL_0ea178dd6d3540bd87787328120fd36b", - "IPY_MODEL_db212b22656948d9a190fc4a1a22d139" - ], - "layout": "IPY_MODEL_7b33cc704c9140f195ac96f687d735e9" - } - }, - "38a1154b2af840c2bfa56f98637ee08d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_56e7ad0645874b6697ee7d6058041638", - "IPY_MODEL_8ce63facf77441cf8015139500564c5d", - "IPY_MODEL_c740afa60993457d959de43a861e200d" - ], - "layout": "IPY_MODEL_f3ab972f1ab14fd69d87e7a9af800aaf" - } - }, - "3a5610b41c5f49d78c2e89e23006cfd9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "3a923915a02341c8adda26e702a58649": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "3ac04713cef64e8cb11d8a4d405726c4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "3b4b83b841ab45bb9a19e08f52bfc887": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "3c1323bad0314e4fa563e498e7bda9f6": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "3c85353efe9b47888787857596cb1741": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "3c8c8708d15d43af8d9a86b752f019c9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_9f1ee508f1b0446797118ce36c038fd4", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_ac11c98a0f884eabb0111353c01533ed", - "value": 1 - } - }, - "3c9251f3f32a49189ed62cf12908b655": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "3cc511d5ba384c10aa8d0d285ae9bc73": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_44500e4704f14a2ba6523013f2f237cb", - "IPY_MODEL_cd2246e275ab4283aea5036a3c083cc3", - "IPY_MODEL_1ba0dee7653247c8b6008c8c60dd40bd" - ], - "layout": "IPY_MODEL_fe23ff3e550a48de82471507e913f733" - } - }, - "3cc8a7fba51942de9e82264e548c62a5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "3cde40f339394878b928ec180b8e4e64": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_d63a1a9bacb04337b03301301ceed042", - "IPY_MODEL_33e6c841c0154edbb81d53bf5de15b9a", - "IPY_MODEL_975b6c14f7204bd39dcfc6af693c85b1" - ], - "layout": "IPY_MODEL_6df28ba2fc2d46cc8b51f0d80c8ba25d" - } - }, - "3de0b3794ad54c45b7c019cfd285a95e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "3e535346524042d1b6d156a73faf2fc9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "3e98332b532745d3bbcac8801aae2a31": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "3ee03c10f050486a953717e911d126c8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "3eff3edded23414db81879b4c2f6f5b8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_789c4051b78e427c80d9505e4144f46a", - "placeholder": "​", - "style": "IPY_MODEL_90f631a62ce44f6db314bd9cf1451074", - "value": "Validation DataLoader 0: 100%" - } - }, - "3f8d2f2e30e54ea9ac57deca09cb34c8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_2902a8dadce1454491f29a01b6655cd3", - "placeholder": "​", - "style": "IPY_MODEL_3515df2d16e14a0284f605d63a48240e", - "value": "Epoch 49: 100%" - } - }, - "3f9b1734cae4441e8e9842e786e3a666": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "40ce8ac2ba224beb9d1cebb9295eae2c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_b5ae1f24f1144a99bbae2c07ab050537", - "IPY_MODEL_2c4a4a15fc154209857e5bc221d4a60b", - "IPY_MODEL_7b6afd64da3f49c48f76feb8b75e54dd" - ], - "layout": "IPY_MODEL_604c401384d042eebd72651c36e9b3e5" - } - }, - "412e24ef862f483093195c1c2dad9700": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "413006fb9d2e453abf39cdd4b91caa75": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "4140dfc3649f489dbdb41c85525ea599": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "4190b291524948279b199476f5533730": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_6438832fe5474201965419106035e40e", - "IPY_MODEL_eb045b2ed03c4f31b6e30f8c54f5e34a", - "IPY_MODEL_14dbde6953364c5c87d9469c49959066" - ], - "layout": "IPY_MODEL_30eef8822a3645bda76c1de7866f2d7a" - } - }, - "425cdf165e3549f592d2c869829a5cfc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_d911964788894e79855e0ae47953103a", - "IPY_MODEL_bb4da1ba8c2c47e084597c70e2441a44", - "IPY_MODEL_4d3fad88182241c99d755adf8e5bbb77" - ], - "layout": "IPY_MODEL_efa4351f438740ebb3b555206fe96b6e" - } - }, - "43130a49034c46deb88430a97b67b772": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "43989ff4ef934577b920e58f7458cc0a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "43ad8d40f2104267a64d02c8a4735f42": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_3250e51e0ed34ad9a8a81354466952bd", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_709b15f575e2439b914968dce170619a", - "value": 1 - } - }, - "43ce5cc7a3794a9faed7a053c984636e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_5955d67a815e42cbbc391fec4784bea1", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_83fa2586801d4cbdac47384f78e906ba", - "value": 1 - } - }, - "44500e4704f14a2ba6523013f2f237cb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_44930c49f41248f38f21e9d23941a1b3", - "placeholder": "​", - "style": "IPY_MODEL_4140dfc3649f489dbdb41c85525ea599", - "value": "Validation DataLoader 0: 100%" - } - }, - "449171807ad14b55876489b49b09bcd8": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "44930c49f41248f38f21e9d23941a1b3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "451d8508824949d0ae06c2be42504f7b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "4526a155d76542528b553180e2c9f107": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_81671ac2f73b48669e505f454b013dca", - "placeholder": "​", - "style": "IPY_MODEL_a289a2fa75f04aae936662ccd032d70f", - "value": "Validation DataLoader 0: 100%" - } - }, - "4671ae95c7024ac9aef90bde31b1cd5a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "475556f9d2db4569b985192b4648a9bb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "47aded72d1e2424f97dc3426fbff540f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_2b2610ec8b884911a15455ebb9f8852b", - "placeholder": "​", - "style": "IPY_MODEL_5429aadaaaaa4767942be28932e6e09a", - "value": "Validation DataLoader 0: 100%" - } - }, - "48333bff75384cf7886c81ca1e3f0056": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "484a5d3a19474d23821c279f602e067d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_dbb3626925144fbb9366336171f85a41", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_eadafdb5fc3d4f3b84df9ae41c5854aa", - "value": 1 - } - }, - "48eed094358c4c33a1fec51e83ad1449": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_faa2148c3d1849708c7c61edd90e1291", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_7ce09c539e7e43239b274b2951847b4e", - "value": 1 - } - }, - "48f5b787955e41189e698f9f842d0523": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "49a0cb79625a46dc9241a2707a27e52a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_8e7e13c148344fcbbe81f9a38bda633b", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_1af74cb9bbf24e2e805ca966acbe0907", - "value": 1 - } - }, - "49e5341ae44b43bc887609a461efc80b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "4a14a6ec2d3348dcbc9875ec7af4e928": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_53f2f6f68bce41c08df12776081ea727", - "IPY_MODEL_a752a853b6da4c9a867cbc4c356a5f86", - "IPY_MODEL_9f59240c317a4919bced1fea1302825f" - ], - "layout": "IPY_MODEL_17e293d4e9764a2c9336651c5186597c" - } - }, - "4a34d533b9374b60aec1d1b6e8935014": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "4a405964924f4527bc988f1679002ea2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "4a8debce9ea84992af1a53c9aaa7470d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_199b2ba5fee04882ae0d71a1f06c8c29", - "IPY_MODEL_10bb79a6159545a9a8e1f0a2e1a2cf03", - "IPY_MODEL_93470f3024cc4db09420bcf82df30ed0" - ], - "layout": "IPY_MODEL_b9b5f84e0ad04dfdaa801aae0759b7c8" - } - }, - "4a9dadfe582049babf7e91c7d956de55": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_7b10ca1619e948dd91248c7ec8b075ef", - "placeholder": "​", - "style": "IPY_MODEL_eabdb0f39f1f43cf8f5e37b2abfc279f", - "value": "Validation DataLoader 0: 100%" - } - }, - "4aec1986363b4a899ff12c1670eb99d4": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "4ba6608f281b443094cd1a057fc56edf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_f110be5d117b49ffb8f696ebeb44fd54", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_9ebee1344386470abd6ecb7c73c114e8", - "value": 1 - } - }, - "4c5db6fbb19943c19b6a91c9ebb72227": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "4cb23d2da234483fab7b0d292aae77d6": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "4cc3497b5dca4bb092237b8dbef8cb8f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "4d3fad88182241c99d755adf8e5bbb77": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_8e6caa11df7d40c880506ce1587d3080", - "placeholder": "​", - "style": "IPY_MODEL_03d29d4401344338a1bc1e840b8a8208", - "value": " 3/3 [00:00<00:00, 22.38it/s]" - } - }, - "4d504ee7c6074c64960523a855043fbc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_ad94f07de5fd480c95d444bf89488537", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_fa210271474f4e82bb4d087e1ffeee4f", - "value": 1 - } - }, - "4d6169d06e3f420abdfe10140b2f1752": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "4e0c287d06814086b4c1b478fb11dfe5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "4e4b06c04fb9400b9a89aacaa0b1926a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_0c1de1c66eed49ad826796f167c875fe", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_9313d0d4d0794c448c119cb081eeefd8", - "value": 1 - } - }, - "4f64f33ec76545669aad6cad0532bf52": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_fe72db6203cc472695e2217021d84b33", - "IPY_MODEL_a4a766bb527240aca3846cb63d9f1e1b", - "IPY_MODEL_682e08c8af3247b8b01a31a113920e4f" - ], - "layout": "IPY_MODEL_904dd3a3be60473c91575ed0105bec04" - } - }, - "4fb03babee474f98bc3f153b930c3973": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "4fd7a055897d495da333b612468f50d3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_2247bf9c5e134d28ac140fa9947cbadd", - "placeholder": "​", - "style": "IPY_MODEL_7b312daa8c8d4f4693a43fb24c9167a7", - "value": " 3/3 [00:00<00:00, 23.55it/s]" - } - }, - "50ac65735b464186a73dd287df8bdb90": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "51a977e26e3246c0bb2f6e079a06a7bc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_174d67b232ac40d695cb15665959ac0c", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_8a991636ec0d4514973402ce7942f200", - "value": 1 - } - }, - "51de3b840a3344c8b1131aa08d0c48af": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_18d30486f46544ba947954cad0897d53", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_5887ca685a454f069902494c857eff62", - "value": 1 - } - }, - "524439135fb54e3ba86f5ace4eb06338": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_b0133d98440d4496995d89a6c3d24a9c", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_81bbb203f78c4e9ca03bae7163d04459", - "value": 1 - } - }, - "52db1d1561db4f5ca9b881ff55320251": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_92b11b42862d464fa908abaeb6a2e437", - "placeholder": "​", - "style": "IPY_MODEL_a1003fa3bcb249b886cfc6a7fb50f3b7", - "value": "Validation DataLoader 0: 100%" - } - }, - "53514d6c6a5747c781da5d5731076fa3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "53f2f6f68bce41c08df12776081ea727": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_ece37dfc7f7846089b7ae9f620da5590", - "placeholder": "​", - "style": "IPY_MODEL_6849f7fa0d6f41ab9c8a3fafadd166b1", - "value": "Validation DataLoader 0: 100%" - } - }, - "5429aadaaaaa4767942be28932e6e09a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "54a4b9d97f1f4908871c6410b0372c9d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "54afe3c681fd4869b5cc34d9aa410881": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "556e1708cb714b7ca1f24dbcc30845cb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "55ebce6aedaf44569ebe813c11d86db0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "561247266aca4a06a29ca8d77d5390f1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "561482bb8bda448b8ac9f924ebac2c49": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "561adb0dc1c943e6ac7734d9d214f35a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "56399d46ad8b44ed8ed0adf329893522": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "5671f7eaab934f108a1202ab876c0da9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "56b57990ab094da3accd27ee807e9a92": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_680893a87c164913972e227461e4853c", - "IPY_MODEL_175aa4436adf4ba699b550ec31f13f8c", - "IPY_MODEL_e4e08a2301f6407eb5cc13c15102efe6" - ], - "layout": "IPY_MODEL_5b2c06adca494ad8b235031e32e3d769" - } - }, - "56ddb3c87b764bdc96a118235ed5c1e1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_12f90753525d4938bd9ccdd3affdf222", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_bedfd3bf09594024adfbcc6c76b3d120", - "value": 1 - } - }, - "56e7ad0645874b6697ee7d6058041638": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_917afa78da954d1e8ad09dd4cf9f4202", - "placeholder": "​", - "style": "IPY_MODEL_0ae94f04037447acb216044112f9175b", - "value": "Validation DataLoader 0: 100%" - } - }, - "5729ea76ec2b4c9eb3f5143f3e5b0a60": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_db7f36c1229c472bbfca23cfc260f4c5", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_77babc7cce66414b87aa437610eb4bd5", - "value": 1 - } - }, - "57a0365d6e264988a9f8340c13cb32ac": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "58034176a80143809a8dfc91a9a3aff3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "586ca83e63894831b02c18cd6d50ac67": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_246b3248809140ce93eb13901bed3892", - "placeholder": "​", - "style": "IPY_MODEL_31eb075cdf584cfa829bc3f119aa9244", - "value": "Validation DataLoader 0: 100%" - } - }, - "5887ca685a454f069902494c857eff62": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "5911fd23e2c840d9a59cadc4fcdb797d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_7ae860cacde943d9b40ce530f3de23e7", - "placeholder": "​", - "style": "IPY_MODEL_2d4feafdf81144ac9ec7610c6bd7bec5", - "value": "Validation DataLoader 0: 100%" - } - }, - "5955d67a815e42cbbc391fec4784bea1": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "59b6ed718ae547519a7520bd0ba8cff6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "59e61b3b77174b06a86e04d5ebda5703": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_8a3f0120a932480fabd5df4bab19b4ee", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_bfe5ecfb0f4c402ca61d4c401882c29f", - "value": 1 - } - }, - "5a20ac379047420483e2e3c281846da8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "5a8d30cc9ab2422094515bd3fa829cf0": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "5ae95da99ca04dd899c2e10cfcb1a4b7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "5b2c06adca494ad8b235031e32e3d769": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "5c2bdf30acb64fde97964052bf1158ea": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "5c49200354514c20bdb71fedbcf634a2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "5c6215db50ab462388024533bc764d6c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_b6f83849585749c9851b2eb021d99f97", - "placeholder": "​", - "style": "IPY_MODEL_2f65e0c84ad0488589d9099d8857e813", - "value": " 3/3 [00:00<00:00, 23.46it/s]" - } - }, - "5c9b296e4e2248bd80b763abfa0d3aa9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_67091d0ab8274792a1ee046e7d5ba315", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_4c5db6fbb19943c19b6a91c9ebb72227", - "value": 1 - } - }, - "5ce8d4f4ca734748adf31e8a5328a430": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "5d09e24e29e94a9493293cb44f2f05ed": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "5d116e6c9d944632a0bb3667425ce1fa": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_2e4b3d2637214494a1e3144a63f6b2d8", - "IPY_MODEL_48eed094358c4c33a1fec51e83ad1449", - "IPY_MODEL_331f64d00dc547d7928e433cd4bffde1" - ], - "layout": "IPY_MODEL_b2f473ff0fdf49698f439d63ad6e6954" - } - }, - "5d11defaa1624b83a8a47e4745a13d7a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "5d21a03a00ed4c4e8772c1b2aa49036e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "5d24e35625b1440fb3e0254d16762b22": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_80f20c8f2c1948c69cd779e36f7066c7", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_5ae95da99ca04dd899c2e10cfcb1a4b7", - "value": 1 - } - }, - "5d57d4c3e3a24cac8a8ab228b199ca22": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "5d738cc2fe5447cb89f343a31554e050": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "5e923969e34848c6851b2b03c7b41841": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "5ee267ba68f04f27a4d44ac895c28be4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "5f21fb315ce049e49d37e44aa6adf375": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "5f8819ebd06e4a3f8dab4a84855019dd": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "60102f86fd2742cdb8c73a720c558b21": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "604c401384d042eebd72651c36e9b3e5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "6113dfc521c64c89abc5c0a20499381f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "6178e85c32c64115bd3105cd74efed18": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_4fb03babee474f98bc3f153b930c3973", - "placeholder": "​", - "style": "IPY_MODEL_22ad0c58d4a94b469e15b425c20edb60", - "value": " 3/3 [00:00<00:00, 23.36it/s]" - } - }, - "61bdef04eaff450ca8d552b7ebc67533": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_08147947751240079f5d4fc1ebb3d2a8", - "IPY_MODEL_656ec0e3fc91481bb1fbd3aec5c9f007", - "IPY_MODEL_f3c46fae7ba04122b9ea6721d3fd59f9" - ], - "layout": "IPY_MODEL_65af6aa005304854b289c94d562ee42c" - } - }, - "61c1424c837a411d91e1e361e2f663fb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_4cb23d2da234483fab7b0d292aae77d6", - "placeholder": "​", - "style": "IPY_MODEL_cfddec8a651f495397214b49f9b8091d", - "value": "Validation DataLoader 0: 100%" - } - }, - "631e42e29fa24b01bdf65a52c5a3789e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_134eb7ee8cc64f68be7803f5d10e415c", - "placeholder": "​", - "style": "IPY_MODEL_a136e3374ce04534a06061f743d710d5", - "value": " 3/3 [00:00<00:00, 22.02it/s]" - } - }, - "6348038c38224d04af7bf57abedabec9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_96a3c2562f2e4d97b8e11bfea7092ad1", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_e51e2fae2577476eb17a5589654e4146", - "value": 1 - } - }, - "6390e224619346a8af81a12030c7fb38": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_72299ab304f54db1a02a56f0d4c0ec54", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_aa0d6cf2f28040c19305a9704740ec23", - "value": 1 - } - }, - "6438832fe5474201965419106035e40e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_3314d1f00dd74034bc28143b99bef726", - "placeholder": "​", - "style": "IPY_MODEL_7e095acd45294cd499418a6dc525ac28", - "value": "Validation DataLoader 0: 100%" - } - }, - "6469faa7ce30401c8406ace5479d0744": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "6513da4ffafb4d01b5c487ac7cf931ae": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_b40b9defd0e54112a478434d87f3d37c", - "IPY_MODEL_afa45e41b7894012966afdceddbdcef9", - "IPY_MODEL_203d55b28e7b4c12940f1af7e0fb5fcd" - ], - "layout": "IPY_MODEL_907e7eeceda44049b47167d5772392d8" - } - }, - "656ec0e3fc91481bb1fbd3aec5c9f007": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_9a70f8e5d1b345bda0c4aecf39e26596", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_5ee267ba68f04f27a4d44ac895c28be4", - "value": 1 - } - }, - "65af6aa005304854b289c94d562ee42c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "66a4a0681ee44eff8f045b7a385cd1a2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "67091d0ab8274792a1ee046e7d5ba315": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "671faaa6260e4b6687d39e69951d7764": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_37b3cad147f74c4397a16ca6883ba98a", - "IPY_MODEL_f977f92cd00040b79d1370265c355470", - "IPY_MODEL_7ee7fbcfa28f4708b85d4721945a34c6" - ], - "layout": "IPY_MODEL_2426adb29a43459895b1f5192654b6ec" - } - }, - "678a690a7ede408fbd504364e0515db1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_705032b0be3741eb8d9f4cc9d3842feb", - "IPY_MODEL_5729ea76ec2b4c9eb3f5143f3e5b0a60", - "IPY_MODEL_5c6215db50ab462388024533bc764d6c" - ], - "layout": "IPY_MODEL_475556f9d2db4569b985192b4648a9bb" - } - }, - "67c16e3db25c47b581acbe130118fbb9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_1c19b3d200d14671994983a2b480d525", - "placeholder": "​", - "style": "IPY_MODEL_9fe0c115193a46c2839b7dba4930ab81", - "value": " 3/3 [00:00<00:00, 23.17it/s]" - } - }, - "67da59c080324e948eeb07890d5ee9da": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_73a668df55a54615ba5bffc804be35af", - "IPY_MODEL_e80004eab2b54b4eafcfab7c2dec94d9", - "IPY_MODEL_2701cb8cf0b64ae0b15efe9c0e32dd01" - ], - "layout": "IPY_MODEL_bb444ac91bbf4b91883b5ccd40b6bd41" - } - }, - "680893a87c164913972e227461e4853c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_cf72bf7126a24a8281cfc4ff0dac558b", - "placeholder": "​", - "style": "IPY_MODEL_59b6ed718ae547519a7520bd0ba8cff6", - "value": "Validation DataLoader 0: 100%" - } - }, - "682e08c8af3247b8b01a31a113920e4f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_c33091d26af94d4f849426d89604efc6", - "placeholder": "​", - "style": "IPY_MODEL_bd210a7aa7724c048560040debfbd7f6", - "value": " 3/3 [00:00<00:00, 17.27it/s]" - } - }, - "6849f7fa0d6f41ab9c8a3fafadd166b1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "68fdb591245f4e2d9df83514d7d5e6bb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "691e3d84fe9642f592bc6621df965af6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "691fc75d0196480c94281c9f8c4e4444": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "6942c1a729a14fb7823c10209797414f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "6a5a24e536314b55952f3ee2d8719970": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "6a703a473224472f9f300236fc25bbe1": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": "100%" - } - }, - "6a9cab5ce8ff43b3a57c47931d4c1cc8": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "6b89e0a40f934cd78aa670de2bbc7158": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "6bfbb82616da41e6aa398500f81eb7b5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_030b37cea4ba414db5fae6384ed6cdb6", - "placeholder": "​", - "style": "IPY_MODEL_f73f08cd498a47eaa01b6ee3e0a9d288", - "value": "Validation DataLoader 0: 100%" - } - }, - "6c3a98e141ef41ebac5033241e901a0a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "6cb7b43df77648d39950587fb4839546": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "6daa75d66b5e4ae9a248ca81f9a973c4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_cdeb0f7de79e4f06b4c76d92d276cb20", - "placeholder": "​", - "style": "IPY_MODEL_72d85446467f44819931d0fc1ef388ca", - "value": " 3/3 [00:00<00:00, 23.28it/s]" - } - }, - "6daeec99a0ec4247b33fcc5424cdf2b1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_3f8d2f2e30e54ea9ac57deca09cb34c8", - "IPY_MODEL_084e9fa8a9924883ab4de7f6ff398d69", - "IPY_MODEL_2ce720e250ef4bcc986904febc125b48" - ], - "layout": "IPY_MODEL_6a703a473224472f9f300236fc25bbe1" - } - }, - "6df28ba2fc2d46cc8b51f0d80c8ba25d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "6e2e3c6c871342c883141e0314353e37": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "6e366f2178ab48519debac50a89d8b9f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_8819541346574b2f9b8ad66a924f66a0", - "IPY_MODEL_484a5d3a19474d23821c279f602e067d", - "IPY_MODEL_6daa75d66b5e4ae9a248ca81f9a973c4" - ], - "layout": "IPY_MODEL_d43d30e849b048c5b038c0ea28051a29" - } - }, - "6e5f2583b8cc4cc8a1218f2c2bec6297": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_449171807ad14b55876489b49b09bcd8", - "placeholder": "​", - "style": "IPY_MODEL_eccaed078ac547328383e1fb8c8422bd", - "value": " 3/3 [00:00<00:00, 19.25it/s]" - } - }, - "6e8070d424684b45bc2d2452edfd1ca6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "6f152e50ae2e433aa01bf9820764022c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "6f5f7d72f10c42f2a13a4e330cd1d96d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "6f6933d25b4147a288c1142f8aa49e24": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "705032b0be3741eb8d9f4cc9d3842feb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_138d51e2eee64063b8347d75eb3002e5", - "placeholder": "​", - "style": "IPY_MODEL_385582d247594701bf07ea19abcc6961", - "value": "Validation DataLoader 0: 100%" - } - }, - "709b15f575e2439b914968dce170619a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "712feb908f5045e39b75f7123bb7dbf6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_50ac65735b464186a73dd287df8bdb90", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_8ad023a1d4414a33bf73eaf801cbd3c4", - "value": 1 - } - }, - "7144eb829e304795b3a54362a2d3308d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "719b5325829f44caa738198d8d8919e2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_2e608130a04c4799993b4ec2f0027f79", - "placeholder": "​", - "style": "IPY_MODEL_2c50e0b4586140f89b5c932f0924d24a", - "value": " 3/3 [00:00<00:00, 21.71it/s]" - } - }, - "719c2567f6c143f2bd88659fdbc158fb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_7e8401965c3e4bce8c7c03f927e647b7", - "placeholder": "​", - "style": "IPY_MODEL_2b88126853b94cf085854107c124e754", - "value": "Sanity Checking DataLoader 0: 100%" - } - }, - "72299ab304f54db1a02a56f0d4c0ec54": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "72823355de9044eba020e56ffe2d3865": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_87dd9bcece474721b57d651815d4115a", - "IPY_MODEL_80202dea9db64ae7987c220a85a7dcac", - "IPY_MODEL_6178e85c32c64115bd3105cd74efed18" - ], - "layout": "IPY_MODEL_0eaa81e3e1d443c387792ee6e64fd1b6" - } - }, - "72d85446467f44819931d0fc1ef388ca": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "73622e0503054ee4aa0a851c245eb607": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_0eca4509b4a94446874ac1614104642b", - "IPY_MODEL_1a6d7e044bf341b88232922836650fef", - "IPY_MODEL_d5ef045581f049caa9d79f10907e526a" - ], - "layout": "IPY_MODEL_02349ea7bced4c8186933cd0134487f2" - } - }, - "73a668df55a54615ba5bffc804be35af": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_9cce801e24c147cea6eb4861b5a55987", - "placeholder": "​", - "style": "IPY_MODEL_885eba97a8bd4006ae9cc9994724c6a8", - "value": "Validation DataLoader 0: 100%" - } - }, - "743dd24c3e314c0590a187f1166bc10e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_da1ce1311a7a49a9b83bd4b6edeb6f98", - "placeholder": "​", - "style": "IPY_MODEL_6e8070d424684b45bc2d2452edfd1ca6", - "value": "Validation DataLoader 0: 100%" - } - }, - "74f2bc8b9aee4fc9986ed0e6d833bab3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "7501155baee5472f9140ac1e04845f75": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "77a3ae393cd54d0f90573d4b2f962c6c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "77babc7cce66414b87aa437610eb4bd5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "783b37e7224247b5ad69a3a9fe83cab0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "7861c5c2fdc54fcd8f3cfb26be5f4dc5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_47aded72d1e2424f97dc3426fbff540f", - "IPY_MODEL_ebbf3193c2ea4b7d98d8504af04bb7e1", - "IPY_MODEL_c9899780726f453b8ef79792b92576cc" - ], - "layout": "IPY_MODEL_6e2e3c6c871342c883141e0314353e37" - } - }, - "789c4051b78e427c80d9505e4144f46a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "79bee0ed60c84ba5aea9f9f0b1314031": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_a097f30c0c204cb9924d6f6bdd709cbe", - "IPY_MODEL_4e4b06c04fb9400b9a89aacaa0b1926a", - "IPY_MODEL_1d903dbd3c9c4f059e5f539cb8d49e80" - ], - "layout": "IPY_MODEL_d83d719827dc4cf18fd6b4be1a013b48" - } - }, - "7a37a6630f874ef1af76b2c89f6fe269": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "7a860c9a51884bc28dbc95be3a5eff52": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_743dd24c3e314c0590a187f1166bc10e", - "IPY_MODEL_6348038c38224d04af7bf57abedabec9", - "IPY_MODEL_e77db813dca54e869bea4a928040769a" - ], - "layout": "IPY_MODEL_101ae0ce1af94c45a5f01989c271074d" - } - }, - "7ae73c7bbf9f4dc7bc28d31f17f6d5d0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "7ae860cacde943d9b40ce530f3de23e7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "7b10ca1619e948dd91248c7ec8b075ef": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "7b312daa8c8d4f4693a43fb24c9167a7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "7b33cc704c9140f195ac96f687d735e9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "7b6afd64da3f49c48f76feb8b75e54dd": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_d93a2657edec4e23a50f067465192ee6", - "placeholder": "​", - "style": "IPY_MODEL_561247266aca4a06a29ca8d77d5390f1", - "value": " 3/3 [00:00<00:00, 22.38it/s]" - } - }, - "7be149c51b0b4709b53a97c054ee154d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "7bea23ddd64f4b229e869423fca4a3fa": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "7c8de7d0ad144b64bbfff2d0851c9ff2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "7cb62ceb722f4d38b9c5d80b32b0841a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_ec1864db512149518a1b0cbbbab057d6", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_bbfe385d70f84c3fa7c22e04a4faa8a3", - "value": 1 - } - }, - "7ce09c539e7e43239b274b2951847b4e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "7d6da8d8ded148e7958e1b747424828a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "7e095acd45294cd499418a6dc525ac28": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "7e8401965c3e4bce8c7c03f927e647b7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "7eaa8bd25f384c9a8ba7fb6faed6b3f7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "7ec6252e85764215b7b94d323aeba6d6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "7ee7fbcfa28f4708b85d4721945a34c6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_0b0b8dfdf0054425b83e8a4994acc8fc", - "placeholder": "​", - "style": "IPY_MODEL_7ec6252e85764215b7b94d323aeba6d6", - "value": " 3/3 [00:00<00:00, 23.64it/s]" - } - }, - "7ef0a9a688f447a98ef9341b72b1a6ba": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "800b1826eb8a4fac98702973a4329c9b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_c8f695256a574888af49e942ff0d53ea", - "placeholder": "​", - "style": "IPY_MODEL_783b37e7224247b5ad69a3a9fe83cab0", - "value": " 3/3 [00:00<00:00, 23.19it/s]" - } - }, - "80202dea9db64ae7987c220a85a7dcac": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_ce568ae8b1bd4bc28cea074e0a295ef0", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_d2232ad66e614f79aa31dacb583eac7e", - "value": 1 - } - }, - "80b7e2aa713a45ca9c2bf8eae7d6bb4d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "80f20c8f2c1948c69cd779e36f7066c7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "81671ac2f73b48669e505f454b013dca": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "819b4436cf3548f29ac4d5ed3fb45eb8": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "81bbb203f78c4e9ca03bae7163d04459": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "827ab09eb5244faaa2bb7737bc38a662": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_0d0222a098a24c4db6e99d2e3f0921ad", - "IPY_MODEL_59e61b3b77174b06a86e04d5ebda5703", - "IPY_MODEL_8874086714df499886c05cfaf1202ff1" - ], - "layout": "IPY_MODEL_215a7a11baf44b5782096bc13d88a0be" - } - }, - "83fa2586801d4cbdac47384f78e906ba": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "84d2ca2125194162937cd60d202efee3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "84deef98024b48efb3f18fae1ee3dffc": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "851f40556b6545f1b2e8b2c49d1f3a24": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "8543f611eeb1412bad6d60f9188daa72": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_899083680c9848b4879aebd89f447fc8", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_cd7c7e091fc24d328e550c0c49fc3a8a", - "value": 1 - } - }, - "87dd9bcece474721b57d651815d4115a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_5c49200354514c20bdb71fedbcf634a2", - "placeholder": "​", - "style": "IPY_MODEL_9546adf443cb47cea6d50a2c4f24fd85", - "value": "Validation DataLoader 0: 100%" - } - }, - "88123fd47960496e989711120607b605": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "8819541346574b2f9b8ad66a924f66a0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_14907f787b0b4e1da4a252d16f1928f9", - "placeholder": "​", - "style": "IPY_MODEL_a0ab8aa511344baf879297df64c2f9fc", - "value": "Validation DataLoader 0: 100%" - } - }, - "885eba97a8bd4006ae9cc9994724c6a8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "8874086714df499886c05cfaf1202ff1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_d8dea74096e64878b237c0a851aac991", - "placeholder": "​", - "style": "IPY_MODEL_e34bdd70106343a5b8612b488b0113f6", - "value": " 3/3 [00:00<00:00, 22.04it/s]" - } - }, - "890891d40cbd42c19ac36100fd39b3c4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_7144eb829e304795b3a54362a2d3308d", - "placeholder": "​", - "style": "IPY_MODEL_3c9251f3f32a49189ed62cf12908b655", - "value": "Validation DataLoader 0: 100%" - } - }, - "899083680c9848b4879aebd89f447fc8": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "8a3f0120a932480fabd5df4bab19b4ee": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "8a991636ec0d4514973402ce7942f200": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "8ad023a1d4414a33bf73eaf801cbd3c4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "8b28746752804efb9514a943d1eaaa40": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_719c2567f6c143f2bd88659fdbc158fb", - "IPY_MODEL_4d504ee7c6074c64960523a855043fbc", - "IPY_MODEL_b0a7821cc80b4d3085d0e3ed5722edd5" - ], - "layout": "IPY_MODEL_a90137b5afbb4831a319bd707ae66e55" - } - }, - "8cba9c6709e5454ea15349dc42cfe0cd": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "8cc548cea0c247d4ae5ab1eeed9cc475": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "8ce63facf77441cf8015139500564c5d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_43989ff4ef934577b920e58f7458cc0a", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_e813e4725c4a43adba6363b551246f61", - "value": 1 - } - }, - "8d6de7a9be714081a8e1369deb51dee6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_256268cbec374eae90521d3b14c86c9f", - "placeholder": "​", - "style": "IPY_MODEL_918c0123e33f453fa046d906e31191f7", - "value": "Validation DataLoader 0: 100%" - } - }, - "8e6a75869f2f4ac5a531530b43b40718": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_02deb853ae5945098b5c1598e0782932", - "placeholder": "​", - "style": "IPY_MODEL_3f9b1734cae4441e8e9842e786e3a666", - "value": " 3/3 [00:00<00:00, 23.41it/s]" - } - }, - "8e6caa11df7d40c880506ce1587d3080": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "8e7e13c148344fcbbe81f9a38bda633b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "8e84599c746a4d149d3f8930f2fab49d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "8f0006a1050e49819bfecf9817429c51": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "8f76fcea6a0a45d1af4d5e4985ababda": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "904dd3a3be60473c91575ed0105bec04": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "907e7eeceda44049b47167d5772392d8": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "90f631a62ce44f6db314bd9cf1451074": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "917afa78da954d1e8ad09dd4cf9f4202": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "918c0123e33f453fa046d906e31191f7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "921a4b00691a4346b04ee18dda85fe9c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "92b11b42862d464fa908abaeb6a2e437": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "9313d0d4d0794c448c119cb081eeefd8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "93470f3024cc4db09420bcf82df30ed0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_412e24ef862f483093195c1c2dad9700", - "placeholder": "​", - "style": "IPY_MODEL_333b116b292148699bda35d8da71f3a8", - "value": " 3/3 [00:00<00:00, 23.96it/s]" - } - }, - "945010c321a84e41828d564ccd6cab17": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_58034176a80143809a8dfc91a9a3aff3", - "placeholder": "​", - "style": "IPY_MODEL_556e1708cb714b7ca1f24dbcc30845cb", - "value": "Validation DataLoader 0: 100%" - } - }, - "94b0542bd9a24f47829d80d75e9e6caf": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "94de6e1f0dc54520b8bf96bec4599f9a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_6bfbb82616da41e6aa398500f81eb7b5", - "IPY_MODEL_6390e224619346a8af81a12030c7fb38", - "IPY_MODEL_0f6cde3fd35f4bf7ad1e8b22a2915a29" - ], - "layout": "IPY_MODEL_277bc910427c41c09786efadfb15e973" - } - }, - "9504247d6ca649aea2ef4ad828f523a6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "9546adf443cb47cea6d50a2c4f24fd85": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "962668142d9b497db0704cbc10129a80": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "966280e648174531853430b876c96b3e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "96a3c2562f2e4d97b8e11bfea7092ad1": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "975b6c14f7204bd39dcfc6af693c85b1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_43130a49034c46deb88430a97b67b772", - "placeholder": "​", - "style": "IPY_MODEL_2e3cf4039bd7412889f96e0f5074d17b", - "value": " 3/3 [00:00<00:00, 18.80it/s]" - } - }, - "97cdd8befbe4449f9a005e3b33848f00": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_8d6de7a9be714081a8e1369deb51dee6", - "IPY_MODEL_56ddb3c87b764bdc96a118235ed5c1e1", - "IPY_MODEL_f5bdab9255224de7ae62b4c83169c022" - ], - "layout": "IPY_MODEL_68fdb591245f4e2d9df83514d7d5e6bb" - } - }, - "995eb88c1ce5422b83ec25f99a059bb0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_308d296e4c784d5e88bf05985a0a6273", - "placeholder": "​", - "style": "IPY_MODEL_996b3a00f07045c48d80011f2f6bf295", - "value": " 3/3 [00:00<00:00, 17.59it/s]" - } - }, - "996b3a00f07045c48d80011f2f6bf295": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "9a367b91d3fb40699363c94d40a21c7c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "9a70f8e5d1b345bda0c4aecf39e26596": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "9bda89af8a87453894b70a571544af1e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "9c0cb0386434437681770e99b0db0744": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_6a9cab5ce8ff43b3a57c47931d4c1cc8", - "placeholder": "​", - "style": "IPY_MODEL_bf19184bcfd74fd6a01f0e791d4b1bb9", - "value": " 3/3 [00:00<00:00, 24.10it/s]" - } - }, - "9cce801e24c147cea6eb4861b5a55987": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "9d7149c5a5174b5da388a5898036e8af": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "9ebee1344386470abd6ecb7c73c114e8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "9f1ee508f1b0446797118ce36c038fd4": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "9f59240c317a4919bced1fea1302825f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_2f1edcd918d446e5bf1c0b48d8ea442f", - "placeholder": "​", - "style": "IPY_MODEL_9fe43efc7832435a91ce56ba8c6b0e71", - "value": " 3/3 [00:00<00:00, 22.88it/s]" - } - }, - "9fe0c115193a46c2839b7dba4930ab81": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "9fe43efc7832435a91ce56ba8c6b0e71": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "a097f30c0c204cb9924d6f6bdd709cbe": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_cc5789103b634ea091fe10e89a0fa387", - "placeholder": "​", - "style": "IPY_MODEL_1c7fe430ec1147afabbc3b8f2733595f", - "value": "Validation DataLoader 0: 100%" - } - }, - "a0ab8aa511344baf879297df64c2f9fc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "a1003fa3bcb249b886cfc6a7fb50f3b7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "a136e3374ce04534a06061f743d710d5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "a1478fa6b5ce4aa9bd0ccee4c50602f5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_57a0365d6e264988a9f8340c13cb32ac", - "placeholder": "​", - "style": "IPY_MODEL_03e87b2770764a44b0fb60c69940fa8a", - "value": " 3/3 [00:00<00:00, 17.11it/s]" - } - }, - "a1b8f183134e41c3969882b651876c05": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "a227c49da5464a3db3817b29583b19a2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_f45de29667c64d98a6d84e5fc642c631", - "IPY_MODEL_cc1285bdc1a74576929e696b39cdff32", - "IPY_MODEL_c11a0b4153bb41229b54f2c316e49fb6" - ], - "layout": "IPY_MODEL_e0b7aafcb493493eb7cc38dcc2e7e790" - } - }, - "a240a470cabe4ec5aba95cbec336c87f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "a289a2fa75f04aae936662ccd032d70f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "a2a5801a03eb4c488bea54a303de8aa8": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "a3c33f5a9a25492aa0e775ed7afe26f2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "a3e103155f8048798c0ac10a88493730": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_e4fa28df40184fef85979ecf49eb0227", - "IPY_MODEL_8543f611eeb1412bad6d60f9188daa72", - "IPY_MODEL_d5cfe8ba6de44341a3a93ad3a4453def" - ], - "layout": "IPY_MODEL_0a5c47146e3841d7826ec9f9ebc4ebaf" - } - }, - "a4a766bb527240aca3846cb63d9f1e1b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_6f5f7d72f10c42f2a13a4e330cd1d96d", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_c65cc31b212940c09f11ceb11c222ef4", - "value": 1 - } - }, - "a52384c27ba84d7ea578c9b8973931f7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "a66f018d98b043a69b1877d53170c040": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "a6b98b78fc9c4106be98cc9c76420e45": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_08050b72b51745a0bb4a6db7eee67474", - "IPY_MODEL_51de3b840a3344c8b1131aa08d0c48af", - "IPY_MODEL_fa8df0bc1a3d4b469ee5f3d25a0f92d2" - ], - "layout": "IPY_MODEL_e2a9cc1c6dea443ca1aa1841fa3fce5a" - } - }, - "a73eb569400d41ff84133f7c31197f10": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "a752a853b6da4c9a867cbc4c356a5f86": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_cf90653728a544029afdf0d285db1b71", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_14dfa39560914f5e9269e122d47adcfa", - "value": 1 - } - }, - "a7e7f2bcb26848f09f12b01bc1820c98": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "a90137b5afbb4831a319bd707ae66e55": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "aa0d6cf2f28040c19305a9704740ec23": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "ab2dcf296209485aa2bdcc204e782715": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "ac11c98a0f884eabb0111353c01533ed": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "acbd9aa0859342e19a0e0ce928d6ad05": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "ad94f07de5fd480c95d444bf89488537": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "ae7f89fa88e4492e8d47b8c7592c1271": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_53514d6c6a5747c781da5d5731076fa3", - "placeholder": "​", - "style": "IPY_MODEL_6113dfc521c64c89abc5c0a20499381f", - "value": "Validation DataLoader 0: 100%" - } - }, - "aee41a66745047fba6a396645a7b8ad2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "afa45e41b7894012966afdceddbdcef9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_a7e7f2bcb26848f09f12b01bc1820c98", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_77a3ae393cd54d0f90573d4b2f962c6c", - "value": 1 - } - }, - "afbf370d7070420baad9e7ce8b643456": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "b0133d98440d4496995d89a6c3d24a9c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "b068791a98704c6e8ab258319dad8263": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "b0a7821cc80b4d3085d0e3ed5722edd5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_3a5610b41c5f49d78c2e89e23006cfd9", - "placeholder": "​", - "style": "IPY_MODEL_b9787a3252ca42b2a28072694afa7def", - "value": " 2/2 [00:00<00:00, 23.01it/s]" - } - }, - "b0f4c8fb387e489b942f9f0d6ae7d8ea": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "b1eabe6afaab4879b4e60b75a13c53f2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "b224a2ff47304317af4868ac6370ffbd": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "b2f473ff0fdf49698f439d63ad6e6954": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "b30a5a9d17284e919da9c824022469c0": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "b40b9defd0e54112a478434d87f3d37c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_2968cd77eaac49d09fc69844d62d533e", - "placeholder": "​", - "style": "IPY_MODEL_24107da359a7483c83160459daa1091c", - "value": "Validation DataLoader 0: 100%" - } - }, - "b462c001fb154c4794053ce3126dd644": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "b560e10add5d49dc875984178fb6c6bb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_586ca83e63894831b02c18cd6d50ac67", - "IPY_MODEL_49a0cb79625a46dc9241a2707a27e52a", - "IPY_MODEL_67c16e3db25c47b581acbe130118fbb9" - ], - "layout": "IPY_MODEL_b0f4c8fb387e489b942f9f0d6ae7d8ea" - } - }, - "b5ae1f24f1144a99bbae2c07ab050537": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_cb153aa133b14ab08dfa44caeeb6b81e", - "placeholder": "​", - "style": "IPY_MODEL_1119633b9b7f45bcb9274237898ae999", - "value": "Validation DataLoader 0: 100%" - } - }, - "b65b184f71e5418299c8c15f2982e874": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "b673982fde464818902b9d9188682521": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_036e4baeb0f84146aad777ed9987dbdb", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_f148afd0ea3a4625a3600fc67c3693ff", - "value": 1 - } - }, - "b6f83849585749c9851b2eb021d99f97": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "b8ff4c15bd8b404d8eba17d813f5a423": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "b9787a3252ca42b2a28072694afa7def": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "b9b5f84e0ad04dfdaa801aae0759b7c8": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "ba5d1cdcc089456b81b50d8e9c033bfa": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "bb444ac91bbf4b91883b5ccd40b6bd41": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "bb4da1ba8c2c47e084597c70e2441a44": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_4a405964924f4527bc988f1679002ea2", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_b8ff4c15bd8b404d8eba17d813f5a423", - "value": 1 - } - }, - "bbc25d75785846ebadf149ac3bc399e2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_c24c9d09c1ff4c4497c11e087cb74601", - "IPY_MODEL_eecb9deb211c43c7b99d28a147d64574", - "IPY_MODEL_f909105afa944e23a3bd7448050b8e24" - ], - "layout": "IPY_MODEL_dd7333bf31cb4da9b0cbe872d706569b" - } - }, - "bbfe385d70f84c3fa7c22e04a4faa8a3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "bc896c2b5a674b58a8f4297c86335e6c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_6cb7b43df77648d39950587fb4839546", - "placeholder": "​", - "style": "IPY_MODEL_3ac04713cef64e8cb11d8a4d405726c4", - "value": "Validation DataLoader 0: 100%" - } - }, - "bc93eb10d7f44b559d17c6b5c6cb93b7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_1088c60e62f64798b702028799231729", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_6b89e0a40f934cd78aa670de2bbc7158", - "value": 1 - } - }, - "bd210a7aa7724c048560040debfbd7f6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "bd24262a245b4a8fa786bc8a172e64d0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "bedfd3bf09594024adfbcc6c76b3d120": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "bf19184bcfd74fd6a01f0e791d4b1bb9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "bf97514daefb48869a318e5e617483a1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_d0fe8f14840146df9fc769f2ffc6f103", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_1dc882f2764548e1a1103da0a7d4052a", - "value": 1 - } - }, - "bfe5ecfb0f4c402ca61d4c401882c29f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "c09e5bcfc73a436e8ab8bce80a2f066c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "c0c48b257aa04dd4883d496f59eb1d82": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "c11a0b4153bb41229b54f2c316e49fb6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_6c3a98e141ef41ebac5033241e901a0a", - "placeholder": "​", - "style": "IPY_MODEL_176b8cafeae846b08bd905108c49c187", - "value": " 3/3 [00:00<00:00, 22.58it/s]" - } - }, - "c171ca6ce6c342e3a2b554f0a1e96946": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_6469faa7ce30401c8406ace5479d0744", - "placeholder": "​", - "style": "IPY_MODEL_55ebce6aedaf44569ebe813c11d86db0", - "value": " 3/3 [00:00<00:00, 22.69it/s]" - } - }, - "c24c9d09c1ff4c4497c11e087cb74601": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_5c2bdf30acb64fde97964052bf1158ea", - "placeholder": "​", - "style": "IPY_MODEL_c42e9afe917b4d238b64c8dae423a08c", - "value": "Validation DataLoader 0: 100%" - } - }, - "c33091d26af94d4f849426d89604efc6": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c3ae2ada559f4a77834b47afeb954e2e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c42e9afe917b4d238b64c8dae423a08c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "c47cbc67f63d4664a525f45cb9be802f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "c65cc31b212940c09f11ceb11c222ef4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "c67eb73d43c449f2801750558f4a521d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c732b4b99e5e43de98eba24ea9330b8c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_a2a5801a03eb4c488bea54a303de8aa8", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_f58e5e4225644425a58df21cc258b2e9", - "value": 1 - } - }, - "c740afa60993457d959de43a861e200d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_84deef98024b48efb3f18fae1ee3dffc", - "placeholder": "​", - "style": "IPY_MODEL_a1b8f183134e41c3969882b651876c05", - "value": " 3/3 [00:00<00:00, 18.03it/s]" - } - }, - "c76e8e95ff844324b72e1ae2a040b673": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "c88525bd6bf54f718d16f5e7b2c8a438": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_043020ee46b04b0e849aa065eb1688e6", - "IPY_MODEL_51a977e26e3246c0bb2f6e079a06a7bc", - "IPY_MODEL_d4614ca1e2ee41e3a78be809c911e5a7" - ], - "layout": "IPY_MODEL_56399d46ad8b44ed8ed0adf329893522" - } - }, - "c8f695256a574888af49e942ff0d53ea": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c91100e69a0e4320a37a979b0586d808": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c9899780726f453b8ef79792b92576cc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_efa1c19e95504fbfb3130ce5d2f9e06e", - "placeholder": "​", - "style": "IPY_MODEL_74f2bc8b9aee4fc9986ed0e6d833bab3", - "value": " 3/3 [00:00<00:00, 23.76it/s]" - } - }, - "cb153aa133b14ab08dfa44caeeb6b81e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "cb3e60255a18440b8bd26c6682520e63": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "cc1285bdc1a74576929e696b39cdff32": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_54afe3c681fd4869b5cc34d9aa410881", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_31a5f2acf0774510a8f94b1dd0c3611f", - "value": 1 - } - }, - "cc5789103b634ea091fe10e89a0fa387": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "cd2246e275ab4283aea5036a3c083cc3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_5d738cc2fe5447cb89f343a31554e050", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_daaac23228ea45da98b5c3819047daf2", - "value": 1 - } - }, - "cd7c7e091fc24d328e550c0c49fc3a8a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "cdeb0f7de79e4f06b4c76d92d276cb20": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "ce568ae8b1bd4bc28cea074e0a295ef0": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "cf72bf7126a24a8281cfc4ff0dac558b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "cf90653728a544029afdf0d285db1b71": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "cfc3eed1a714480ea5c25697e9cfb760": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_3083d2e358de4e00a24910dbff9d83d0", - "IPY_MODEL_ed779a27748c4413b93ddae88e3b6847", - "IPY_MODEL_4fd7a055897d495da333b612468f50d3" - ], - "layout": "IPY_MODEL_ff128da02ac640b8815356d193efb837" - } - }, - "cfddec8a651f495397214b49f9b8091d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "d00f6502d78f48a6afd47fef76056b0c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_8cba9c6709e5454ea15349dc42cfe0cd", - "placeholder": "​", - "style": "IPY_MODEL_f9b7ccdfa2be41a7a8f7a7a64699b47a", - "value": " 3/3 [00:00<00:00, 23.70it/s]" - } - }, - "d0e3de0c45944a3ca22baafdb51612b6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_ec0d2f874c0b4d90b70dab8a364a7177", - "placeholder": "​", - "style": "IPY_MODEL_0aed735a0bef4bca94cc0f83fc6bb741", - "value": " 3/3 [00:00<00:00, 22.95it/s]" - } - }, - "d0fe8f14840146df9fc769f2ffc6f103": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "d169d623177b4f73a73034c7f0b50b5d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "d2232ad66e614f79aa31dacb583eac7e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "d2b1934184984f6da6e2a9f0cc091e2e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_f0c011f3be21460f8b128ff280d68808", - "IPY_MODEL_712feb908f5045e39b75f7123bb7dbf6", - "IPY_MODEL_a1478fa6b5ce4aa9bd0ccee4c50602f5" - ], - "layout": "IPY_MODEL_7a37a6630f874ef1af76b2c89f6fe269" - } - }, - "d43d30e849b048c5b038c0ea28051a29": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "d4614ca1e2ee41e3a78be809c911e5a7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_e8f6d51de5214b58938e06faacf9e90f", - "placeholder": "​", - "style": "IPY_MODEL_c76e8e95ff844324b72e1ae2a040b673", - "value": " 3/3 [00:00<00:00, 23.03it/s]" - } - }, - "d4ca8a1f229148a880d420776312aff2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "d5cfe8ba6de44341a3a93ad3a4453def": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_021e47894cca42c88d89421b56dfb919", - "placeholder": "​", - "style": "IPY_MODEL_3cc8a7fba51942de9e82264e548c62a5", - "value": " 3/3 [00:00<00:00, 23.53it/s]" - } - }, - "d5ef045581f049caa9d79f10907e526a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_6942c1a729a14fb7823c10209797414f", - "placeholder": "​", - "style": "IPY_MODEL_0d91c6de914d46af8891967ed2d6775a", - "value": " 3/3 [00:00<00:00, 23.22it/s]" - } - }, - "d61e750471554974ae9b07a81dce6932": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "d63a1a9bacb04337b03301301ceed042": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_7ef0a9a688f447a98ef9341b72b1a6ba", - "placeholder": "​", - "style": "IPY_MODEL_5671f7eaab934f108a1202ab876c0da9", - "value": "Validation DataLoader 0: 100%" - } - }, - "d794297461194c3d98cbf0f27d30b67a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "d83d719827dc4cf18fd6b4be1a013b48": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "d8dea74096e64878b237c0a851aac991": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "d911964788894e79855e0ae47953103a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_66a4a0681ee44eff8f045b7a385cd1a2", - "placeholder": "​", - "style": "IPY_MODEL_6a5a24e536314b55952f3ee2d8719970", - "value": "Validation DataLoader 0: 100%" - } - }, - "d93a2657edec4e23a50f067465192ee6": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "da1ce1311a7a49a9b83bd4b6edeb6f98": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "da6176592b274c47aaeecc2428c76c9c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_273f928c594e471290863f82079d9180", - "IPY_MODEL_43ce5cc7a3794a9faed7a053c984636e", - "IPY_MODEL_c171ca6ce6c342e3a2b554f0a1e96946" - ], - "layout": "IPY_MODEL_df60c4135a444a448b0d200ecdd01e43" - } - }, - "daaac23228ea45da98b5c3819047daf2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "db212b22656948d9a190fc4a1a22d139": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_94b0542bd9a24f47829d80d75e9e6caf", - "placeholder": "​", - "style": "IPY_MODEL_3ee03c10f050486a953717e911d126c8", - "value": " 3/3 [00:00<00:00, 21.91it/s]" - } - }, - "db7f36c1229c472bbfca23cfc260f4c5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "dbb3626925144fbb9366336171f85a41": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "dce8d86194e345cc9fe8792d1bd457e8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_3eff3edded23414db81879b4c2f6f5b8", - "IPY_MODEL_3c8c8708d15d43af8d9a86b752f019c9", - "IPY_MODEL_d00f6502d78f48a6afd47fef76056b0c" - ], - "layout": "IPY_MODEL_ab2dcf296209485aa2bdcc204e782715" - } - }, - "dd7333bf31cb4da9b0cbe872d706569b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "df60c4135a444a448b0d200ecdd01e43": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "e0b7aafcb493493eb7cc38dcc2e7e790": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "e2362e5efae7467b8e58786955739072": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "e2a9cc1c6dea443ca1aa1841fa3fce5a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "e2f90203e06442c88ac36903ea85f8e7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_962668142d9b497db0704cbc10129a80", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_3c85353efe9b47888787857596cb1741", - "value": 1 - } - }, - "e3308390869847b1a8c4123b5350f9d7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "e34bdd70106343a5b8612b488b0113f6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "e4e08a2301f6407eb5cc13c15102efe6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_2ee030af4e5541489a20050aad8efce5", - "placeholder": "​", - "style": "IPY_MODEL_d169d623177b4f73a73034c7f0b50b5d", - "value": " 3/3 [00:00<00:00, 22.39it/s]" - } - }, - "e4fa28df40184fef85979ecf49eb0227": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_29dad287ff434262917e99d4abe87e22", - "placeholder": "​", - "style": "IPY_MODEL_b068791a98704c6e8ab258319dad8263", - "value": "Validation DataLoader 0: 100%" - } - }, - "e51e2fae2577476eb17a5589654e4146": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "e56dddf291fc4a87a8abcf35deb3ada4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_a66f018d98b043a69b1877d53170c040", - "placeholder": "​", - "style": "IPY_MODEL_22d5c7797b224ceeab780e907164a7f8", - "value": " 3/3 [00:00<00:00, 23.31it/s]" - } - }, - "e6cf9c9bda7b4d37a0ea40d0565bdc25": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_d4ca8a1f229148a880d420776312aff2", - "placeholder": "​", - "style": "IPY_MODEL_7eaa8bd25f384c9a8ba7fb6faed6b3f7", - "value": "Validation DataLoader 0: 100%" - } - }, - "e77db813dca54e869bea4a928040769a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_b65b184f71e5418299c8c15f2982e874", - "placeholder": "​", - "style": "IPY_MODEL_49e5341ae44b43bc887609a461efc80b", - "value": " 3/3 [00:00<00:00, 22.78it/s]" - } - }, - "e80004eab2b54b4eafcfab7c2dec94d9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_1f272fa725454bb3bf529bdf2604eb12", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_279a78ac51154592a3d288be64dc843f", - "value": 1 - } - }, - "e813e4725c4a43adba6363b551246f61": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "e8d243e979184d43b46d66e8eaeec7fc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "e8eead01a58840588b916d34bac88da9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_890891d40cbd42c19ac36100fd39b3c4", - "IPY_MODEL_4ba6608f281b443094cd1a057fc56edf", - "IPY_MODEL_e56dddf291fc4a87a8abcf35deb3ada4" - ], - "layout": "IPY_MODEL_3593ff33dc6a422691e37ae61708a66b" - } - }, - "e8f6d51de5214b58938e06faacf9e90f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "e9add7d8e3534205a85161a1dd8c0561": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_22da81f202af4f88849537be607e9ee3", - "placeholder": "​", - "style": "IPY_MODEL_eac934f0739245f6ab3366ce113ca5ea", - "value": "Validation DataLoader 0: 100%" - } - }, - "ea77318badcd47a48dc6631fc4b34705": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_bc896c2b5a674b58a8f4297c86335e6c", - "IPY_MODEL_524439135fb54e3ba86f5ace4eb06338", - "IPY_MODEL_8e6a75869f2f4ac5a531530b43b40718" - ], - "layout": "IPY_MODEL_5e923969e34848c6851b2b03c7b41841" - } - }, - "eabdb0f39f1f43cf8f5e37b2abfc279f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "eac934f0739245f6ab3366ce113ca5ea": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "eadafdb5fc3d4f3b84df9ae41c5854aa": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "eb045b2ed03c4f31b6e30f8c54f5e34a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_4e0c287d06814086b4c1b478fb11dfe5", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_451d8508824949d0ae06c2be42504f7b", - "value": 1 - } - }, - "eb974dbc33d040f9b178b3a77dd40596": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "ebbf3193c2ea4b7d98d8504af04bb7e1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_d61e750471554974ae9b07a81dce6932", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_7d6da8d8ded148e7958e1b747424828a", - "value": 1 - } - }, - "ebd8e5f5fc36423e854f3eb3d01a3ccb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_4526a155d76542528b553180e2c9f107", - "IPY_MODEL_43ad8d40f2104267a64d02c8a4735f42", - "IPY_MODEL_f0d35a683ffe4f61a9ed609a837b0cc7" - ], - "layout": "IPY_MODEL_201b24c9f69c4af18145260bb4ecb762" - } - }, - "ec0d2f874c0b4d90b70dab8a364a7177": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "ec1864db512149518a1b0cbbbab057d6": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "eccaed078ac547328383e1fb8c8422bd": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "ece37dfc7f7846089b7ae9f620da5590": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "ed779a27748c4413b93ddae88e3b6847": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_091cf2b9b40b414e9463f51088f93be9", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_bd24262a245b4a8fa786bc8a172e64d0", - "value": 1 - } - }, - "eecb9deb211c43c7b99d28a147d64574": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_a52384c27ba84d7ea578c9b8973931f7", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_2a928efa36a84ee6b7ddd50505f8bed9", - "value": 1 - } - }, - "efa1c19e95504fbfb3130ce5d2f9e06e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "efa4351f438740ebb3b555206fe96b6e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "f0607bf5f1644ca2950b93029d08cdef": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "f0c011f3be21460f8b128ff280d68808": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_5f8819ebd06e4a3f8dab4a84855019dd", - "placeholder": "​", - "style": "IPY_MODEL_103b137bb36a47fcbbbe9b0c3f2e2a20", - "value": "Validation DataLoader 0: 100%" - } - }, - "f0d35a683ffe4f61a9ed609a837b0cc7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_e3308390869847b1a8c4123b5350f9d7", - "placeholder": "​", - "style": "IPY_MODEL_17bdd1be5491412cacbecb7feeae2fc7", - "value": " 3/3 [00:00<00:00, 23.20it/s]" - } - }, - "f110be5d117b49ffb8f696ebeb44fd54": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "f12bed710be1411f8e30968f4e09554e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_e6cf9c9bda7b4d37a0ea40d0565bdc25", - "IPY_MODEL_7cb62ceb722f4d38b9c5d80b32b0841a", - "IPY_MODEL_9c0cb0386434437681770e99b0db0744" - ], - "layout": "IPY_MODEL_413006fb9d2e453abf39cdd4b91caa75" - } - }, - "f148afd0ea3a4625a3600fc67c3693ff": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "f3ab972f1ab14fd69d87e7a9af800aaf": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "f3c46fae7ba04122b9ea6721d3fd59f9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_b1eabe6afaab4879b4e60b75a13c53f2", - "placeholder": "​", - "style": "IPY_MODEL_561adb0dc1c943e6ac7734d9d214f35a", - "value": " 3/3 [00:00<00:00, 23.18it/s]" - } - }, - "f45de29667c64d98a6d84e5fc642c631": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_88123fd47960496e989711120607b605", - "placeholder": "​", - "style": "IPY_MODEL_f0607bf5f1644ca2950b93029d08cdef", - "value": "Validation DataLoader 0: 100%" - } - }, - "f58e5e4225644425a58df21cc258b2e9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "f5bdab9255224de7ae62b4c83169c022": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_8f76fcea6a0a45d1af4d5e4985ababda", - "placeholder": "​", - "style": "IPY_MODEL_fea61d5d08c349faae33df0f4b6cbbb9", - "value": " 3/3 [00:00<00:00, 20.76it/s]" - } - }, - "f62028910b1a4e299444705e7795058c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_5d11defaa1624b83a8a47e4745a13d7a", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_5d57d4c3e3a24cac8a8ab228b199ca22", - "value": 1 - } - }, - "f65b58b468a442fa9eeef48cccb9164f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_cb3e60255a18440b8bd26c6682520e63", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_0b1024f20aaa459aabd611e80ae46e53", - "value": 1 - } - }, - "f73f08cd498a47eaa01b6ee3e0a9d288": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "f88883a2b4ba433692a7d91e76cb64c2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_170c77c2f53347eba458933ccc9fade6", - "IPY_MODEL_b673982fde464818902b9d9188682521", - "IPY_MODEL_631e42e29fa24b01bdf65a52c5a3789e" - ], - "layout": "IPY_MODEL_c47cbc67f63d4664a525f45cb9be802f" - } - }, - "f909105afa944e23a3bd7448050b8e24": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_07b7b5dcb848469e8f53eeedf1bc6b33", - "placeholder": "​", - "style": "IPY_MODEL_3a923915a02341c8adda26e702a58649", - "value": " 3/3 [00:00<00:00, 23.53it/s]" - } - }, - "f977f92cd00040b79d1370265c355470": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_d794297461194c3d98cbf0f27d30b67a", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_27807cb739b249a59a6e0d9d317414df", - "value": 1 - } - }, - "f9b7ccdfa2be41a7a8f7a7a64699b47a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "fa210271474f4e82bb4d087e1ffeee4f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "fa8df0bc1a3d4b469ee5f3d25a0f92d2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_2fa9970eb2344e038499dc2a08791f13", - "placeholder": "​", - "style": "IPY_MODEL_48333bff75384cf7886c81ca1e3f0056", - "value": " 3/3 [00:00<00:00, 18.40it/s]" - } - }, - "faa2148c3d1849708c7c61edd90e1291": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "fb12c181ee7d42c7aa4256347200bea4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_c67eb73d43c449f2801750558f4a521d", - "placeholder": "​", - "style": "IPY_MODEL_c0c48b257aa04dd4883d496f59eb1d82", - "value": "Validation DataLoader 0: 100%" - } - }, - "fc0b3426a46844028503ab46da1230fe": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "fdd0ef85a11e431c8b9584622aa675f0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_3389a58f19334452a8a25dbe5e19f09a", - "placeholder": "​", - "style": "IPY_MODEL_afbf370d7070420baad9e7ce8b643456", - "value": "Validation DataLoader 0: 100%" - } - }, - "fe23ff3e550a48de82471507e913f733": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "fe72db6203cc472695e2217021d84b33": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_966280e648174531853430b876c96b3e", - "placeholder": "​", - "style": "IPY_MODEL_80b7e2aa713a45ca9c2bf8eae7d6bb4d", - "value": "Validation DataLoader 0: 100%" - } - }, - "fea61d5d08c349faae33df0f4b6cbbb9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "ff128da02ac640b8815356d193efb837": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "ff75dc1b2fbd42dd804840d7a2e6a5e3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "ffae1f6825c045178ae33dea1d805c87": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_fb12c181ee7d42c7aa4256347200bea4", - "IPY_MODEL_bc93eb10d7f44b559d17c6b5c6cb93b7", - "IPY_MODEL_209c4f3f80e14a969afb2b32c7216dbd" - ], - "layout": "IPY_MODEL_2345ab7c9cfb4dc295f34c54579408fb" - } - } - } - } - }, - "nbformat": 4, - "nbformat_minor": 5 -}