diff --git "a/notebook_for_colab/pLDM_inference_standalone_colab_HG_Beta.ipynb" "b/notebook_for_colab/pLDM_inference_standalone_colab_HG_Beta.ipynb" new file mode 100644--- /dev/null +++ "b/notebook_for_colab/pLDM_inference_standalone_colab_HG_Beta.ipynb" @@ -0,0 +1,11616 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5093355f-b45c-483e-a8da-8753eb1536c2", + "metadata": { + "id": "5093355f-b45c-483e-a8da-8753eb1536c2" + }, + "source": [ + "\n", + " \"Open\n", + "" + ] + }, + { + "cell_type": "markdown", + "id": "xQvn0r7NYIgW", + "metadata": { + "id": "xQvn0r7NYIgW" + }, + "source": [ + "## 0. Preparation:\n", + "### 0-1. Add packages" + ] + }, + { + "cell_type": "code", + "source": [ + "from huggingface_hub import hf_hub_download\n", + "from huggingface_hub import snapshot_download" + ], + "metadata": { + "id": "_w-2nfAOO-TB" + }, + "id": "_w-2nfAOO-TB", + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "!pwd" + ], + "metadata": { + "id": "wnJqh2ZdSldR", + "outputId": "b92dfb3b-31a6-4214-e328-1e3147d5a005", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "id": "wnJqh2ZdSldR", + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "/content\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# download everything from the HG repository\n", + "snapshot_download(\n", + " repo_id=\"Bo-Ni/ProteinMechanicsDiffusionDesign_BetaTest\",\n", + " local_dir='/content',\n", + " local_dir_use_symlinks=False,\n", + " revision='main'\n", + ")" + ], + "metadata": { + "id": "E0hgsy3gSQcq", + "outputId": "6071f89d-4476-4768-9315-38687b5fed9b", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 547, + "referenced_widgets": [ + "31b76154485744478e55cc7d644fe746", + "b91214c632844be79784f736e0286379", + "8377bd6062634dc0a7c3859dd5f8ecb7", + "d07fe0b5583f42ceb02fc5868b438d53", + "48308612cb754c008454fc38ed384b52", + "598765bb9ff44e27a9859be5cf509085", + "26b86f56191e445d83e8be32a97b9d9c", + "06254cd412fe49a593e403e623443936", + "ec3d80bb4e5d4b5ea97b5fc8501bfd88", + "606c8307e71f4aeb93c01efa7ec6ef1b", + "2e7e5ae5dc7d4fd5ad8c3454c8d1a8b3", + "6e4183f68b8e45578b723d6c22b2131d", + "43f46bf3a1ac4cbbb7d02fab05409616", + "1bef507bea924964b98351fa40e5ef5c", + "521ca46708fd475e9aab84315a5134e9", + "e503a7ba732849c794876e389608b87e", + "2f131547fd8749dc844d305da218b2b7", + "2e193afeaeff448499bee67461232fae", + "163874d15eb64530ba139f51665897bb", + "71d597ffa540452d9a5862670ad80ed9", + "35506943c1a347209ff1afaf201f8e78", + "23e18ee6795c4a5dae9de8ea2a0189ee", + "4f97f85d76e04a909c6109d3763538f3", + "c35fa7d83d2a4025a17cd968d12f3513", + "9fd13b4d8dfc43919826d8fc8946f852", + "cf5f5f84fc034480b444c25e9a739306", + "40076a4b6dee46c7beddd312ec0bcc68", + "91602dce765e45f7826320373adb610e", + "8daa30bf214b4b93a32ef3cd7a579a35", + "2fb57a342a4f4530a0bbd0075cccde6b", + "92139a49b52d4c16b0a7cbed62959945", + "2467748981b34d589df1ad9afe26ec44", + "bf93ac54779a4effbac95750b47a2ec4", + "8946e09a59d54d28824feeda129ec3df", + "ee3181f0224f4c9b8ffc4a7b811d43c2", + "8a01cc48caa84fb88da774ff60ba1161", + "aa98db21228942c09f738a58d6b9eb45", + "600f5cdae4c44f918497e6740f097938", + "18536412cf204a7bb3cdba37c1080a10", + "54475c76a710459a81757cd2375dc55e", + "a98db38ebf3b4f5f8ac47b0654df59ef", + "5ce184dd537349b4b495f18b71f32c70", + "8436eac1684b4af5bfb0bdc570a8c07a", + "62e753d05ad040e2811c5cbbc99368cb", + "8db11ff9354e4eb4978f169e0d106702", + "3b0c6ac29eb64c7dad5234df2988609c", + "7e3024f69bb8421796ee4f13160e771b", + "c078477b2f5b49aba535a767c63ca960", + "2615f70d9cee402c9fe7d87de3b03751", + "492b0898427d4236af7aa14db39d7095", + "a10b5601aa1945b58d9d00ebf6aaef4c", + "0120d6ece55d49da8d7edfebc0ce2428", + "81961147224f490ebcfbbf051f80cfe9", + "2a454d13caf349ddac93bef841abbe95", + "5899063f548c4288bfbb4c536282dd25", + "d95e3a7b0dbf4bab8952653661411002", + "e57efe4c1b6040f0a4ebed57af9fafa7", + "f01c3a76902e4baab545d4fa55cb406f", + "d3922d8e2b5b4844ac13b352f1458b90", + "df10d508ddac4bf08649cf141dc820af", + "f7cd2e14af8b4b239bc4c9720ae4a126", + "7dee81aa62bb47759537e70156d92a2b", + "f1c9b154b1a14066ac49f7379f73b276", + "9101600fd21747d782743fd719fdbc6e", + "2e2590bd707e4df08f04ba40f5078cef", + "9526e4debf5c42fe984edc3697969bda", + "1e0dcf3e6ec642a0a7a262ae3ba64423", + "93e094d9622e43a2b978d1705444787f", + "fda184abe87441bf842e0d223fc88f69", + "62e5273f963d4de1a8cfd3778de85a38", + "e0468bbf403442cf8bec34717d1ab2f0", + "6dd7fbe246f1486897145702d920a8f2", + "9cdf097f914f40f38ca05c5333140b1d", + "e6d7b24d4f3c45df96fb2ad1b8362182", + "437bf4b0c3e549e2a51b93e71757355e", + "7ba49690b88f4c329a669b736c2390cb", + "9153427390874b4e8dc30aad8f7534d4", + "d8642b7617904b1e99d60058fe591bfb", + "a0b2f6e911554904b8416daf41014877", + "8ee0c34fb57f402e8ad281ee9d9103b6", + "3988f07b8cf242819c200344b7533bb1", + "4d276cde65474631b9005d9c37bcc632", + "197b8fc5756c4172a019a1ba781a6948", + "bdf81bd0021c4d53afc6421bbd7550ca", + "9fd3ad949ed64b3eba606bdd9b4a0bb9", + "0150e43dd40a4829a6f7cd4b2aefffb1", + "fe61e35062bf4fdcb25b995cc1e94606", + "e6cc826c0c8149cd889897e77b73583b", + "466a8c0cf92b48aaa9456edcf189359c", + "ac6eba851ffa4bef8677d9a88728b6ec", + "b43290c3564143e6a0db29a28f483aa9", + "97457f41555f4285af7f78364ff00391", + "7b5ec9d323ba4903aed101fc33c1fe53", + "0007b124c85943c6a7931b60f0314dec", + "a0f47e73b7014204b56d34addddb2b47", + "b1ffbe10a3564cca8c61982d7e3691b3", + "74f2b10f9ae74a4a8f1e02224bf7efd0", + "d240547dda464fa6a711d8402de97909", + "f922730449664c92b0c97abdd7b04869", + "8e735dd693834425b12c75b630516e65", + "a7a0dfe5759e4dbbb038819ee31d5aff", + "71490e2421114d76ad7d8ba44019032e", + "5125a5c2bf784074a0ca831ee537b33d", + "67934b32d2d648ddbf942687e6b9cf95", + "24a3e1ba23a94e548d59a7a4e0f16d47", + "dd0bd71ecd544d83b130cfc02ede8fd4", + "05b54d61fdad4c43a2751a5432aa08bf", + "ea6aed1be6004b91a8c69ddae0b603f1", + "8a1c75d147e246bab942911f8c0d5fe0", + "f892e01a42b548518415c3b01bf21e05", + "01196943b43543b8b37813fc08ae9b59", + "b091a4ae8b484cdda67d42c5fe35a2cc", + "6b6949dd2c884140a5ced117399c3209", + "eb0bfb3302dc44b494c4294898878095", + "ae16b52ea1b84fbaad9f86724b47bf8c", + "ef11f302c91647ce82e4afb5ba74977d", + "fdfc9d83f68b410f841b174f9137f775", + "4730bbfff16b4f2b969684b455eb2659", + "7eb7484118fb494c8435d949bb737a5e", + "2940f69ec013406fa021767648a867d0", + "2a4f553da4554c688a3eff6900d2da49", + "61243205ef664695a875b702ec4ad477", + "6104bb58b9bf4842832547c15d245062", + "7381e16abd80451faa4a57df4efe9a1a", + "56d80ab8e3254e2ba1bb2cb8092bc6e5", + "c509a31ec4db4c1a9c9fa239370218f2", + "8adf0e212a624ea281ebda67d5ff2902", + "7ffb49f4f4e14478b6e58777be7ec5b0", + "0bb4f6caa0bf47adba5e46f1ab21af4a", + "60c4707a19c84c94862e1ead0e8e35d4", + "92f10e1dec9546ba91656be340657ad9", + "7f66067f4b084d06a801d30c9480eb3f", + "127bb6cf455a464b8c310cd3e7391ee7", + "d08703bfa18a4d8c82384a62d3880303", + "ad79567db4f743bbaf034ec93f9ea459", + "5a53e60a144949c38521c936530236e5", + "203a295b78c341578b205addca9ca4a2", + "27e14517288547e2bd61585b4a81b265", + "3945a03afc6d4437a58626bf84bccbf1", + "9bb2bee68f41432b931e8959e5e7ff9c", + "b8fe9f9fdd0e4fbabf5092801ffde0a2", + "ab7c4d5f1c244d51875a82f307ca4ac9", + "8aecf07975164da1983684e9b1ba5b8d", + "c715294e3af94ed6a84d41257fb1ebd8", + "0806463940cc494f8cc3e4403719c088", + "a4a2c89211bb4c30aaee0b422f21dfcd", + "129bcf067c34499181ef68e5ec6983da", + "f940ca44ab86458686ca8590ffb86f8a", + "f6166cb5676144e59b24978a0c35fd81", + "4034623f97704b0bbae1ecbac8a14feb", + "ebc72a111b884a0da552c416852735c6", + "a822016ea3984b02b953ee3f611de747", + "2f7f8af1674f456f942e4df889a10658", + "c982dd7718474ccebfc3e9e072b0f7db", + "a5ad8853f0c84acd9329dbe66400677c", + "a708d6a943764823827b3991911b4545", + "6b582ec702eb4985b72ed33446c970c3", + "9aba2669e8314d22ad68e2f85fed53dc", + "527f9b7bd3ff4601a5464cf9f4c44b97", + "d79a2eab006b4023affbd3f3e50d2767", + "4a9d3d8b88114ae1af3d61c5e5944b15", + "276909a5fe684555a13332f95e6fae36", + "d22334856a5a401b98ebdea3b6929ce5", + "34325901472d40489ec31f9de1dc31de", + "c126d9cad639494983454e01464d76ac", + "a1f099b6335f4edc8ac09a07f61c5ca1", + "fb86e9e80a3d401ebeba7e61ada616d6", + "473a285c607148ecafafc189a4fd99be", + "db081c2664ef4a5fbf91ad04469a55cf", + "e60886445f0540acb562398ef347048b", + "f937c6638513488b8bf7c82193e1bf5f", + "16b511679b034f4d91427cbcd334e8fa", + "972949e856ee48539cdabbb4dadc87a4", + "75907672dabf4f828973a67ca8776c3a", + "763ce29864c74c3a86881a9ef9e00893", + "6f2a94f1a67e494f8c41903e7d8c7046" + ] + } + }, + "id": "E0hgsy3gSQcq", + "execution_count": 3, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Fetching 15 files: 0%| | 0/15 [00:00=5.3.0 in /usr/local/lib/python3.10/dist-packages (from torchvision==0.13.0+cu113) (9.4.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->torchvision==0.13.0+cu113) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->torchvision==0.13.0+cu113) (3.6)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->torchvision==0.13.0+cu113) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->torchvision==0.13.0+cu113) (2023.11.17)\n", + "Installing collected packages: torch, torchvision, torchaudio\n", + "Successfully installed torch-1.12.0+cu113 torchaudio-0.12.0+cu113 torchvision-0.13.0+cu113\n", + "\n", + "Torch version: 1.12.0+cu113\n", + "\u001b[1;32m For the 1st run, \n", + "a. Install omegafold...\n", + "Collecting git+https://github.com/HeliXonProtein/OmegaFold.git\n", + " Cloning https://github.com/HeliXonProtein/OmegaFold.git to /tmp/pip-req-build-29m8caf8\n", + " Running command git clone --filter=blob:none --quiet https://github.com/HeliXonProtein/OmegaFold.git /tmp/pip-req-build-29m8caf8\n", + " Resolved https://github.com/HeliXonProtein/OmegaFold.git to commit 313c873ad190b64506a497c926649e15fcd88fcd\n", + " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "Collecting torch@ https://download.pytorch.org/whl/cu113/torch-1.12.0%2Bcu113-cp310-cp310-linux_x86_64.whl (from OmegaFold==0.0.0)\n", + " Using cached https://download.pytorch.org/whl/cu113/torch-1.12.0%2Bcu113-cp310-cp310-linux_x86_64.whl (1837.6 MB)\n", + "Collecting biopython (from OmegaFold==0.0.0)\n", + " Downloading biopython-1.81-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.1 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.1/3.1 MB\u001b[0m \u001b[31m15.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from biopython->OmegaFold==0.0.0) (1.23.5)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from torch@ https://download.pytorch.org/whl/cu113/torch-1.12.0%2Bcu113-cp310-cp310-linux_x86_64.whl->OmegaFold==0.0.0) (4.5.0)\n", + "Building wheels for collected packages: OmegaFold\n", + " Building wheel for OmegaFold (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for OmegaFold: filename=OmegaFold-0.0.0-py3-none-any.whl size=55664 sha256=7c688332cd65e047de8b3b5bd070f4632b3bd8ca9a1a96cc70827b833071b44a\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-zp2qce52/wheels/fe/57/01/3ce12996dd37debe3ee6a02e8748fffdd4df7b885c5bb8071d\n", + "Successfully built OmegaFold\n", + "Installing collected packages: biopython, OmegaFold\n", + "Successfully installed OmegaFold-0.0.0 biopython-1.81\n", + "--2023-12-20 19:38:07-- https://helixon.s3.amazonaws.com/release1.pt\n", + "Resolving helixon.s3.amazonaws.com (helixon.s3.amazonaws.com)... 54.231.227.121, 52.217.134.145, 52.217.130.249, ...\n", + "Connecting to helixon.s3.amazonaws.com (helixon.s3.amazonaws.com)|54.231.227.121|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 3181611124 (3.0G) [binary/octet-stream]\n", + "Saving to: ‘/root/.cache/omegafold_ckpt/model.pt’\n", + "\n", + "/root/.cache/omegaf 100%[===================>] 2.96G 24.6MB/s in 1m 52s \n", + "\n", + "2023-12-20 19:39:59 (27.2 MB/s) - ‘/root/.cache/omegafold_ckpt/model.pt’ saved [3181611124/3181611124]\n", + "\n", + "b. Install DSSP...\n", + " excuting mv Model_files/mkdssp /opt/bin/mkdssp\n", + "\n" + ] + } + ], + "source": [ + "#@title ####For omegafold\n", + "\n", + "import os,sys\n", + "import math\n", + "\n", + "#os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"-1\" #turn off CUDA if needed\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"\n", + "\n", + "# choose where to download files\n", + "IF_download_from_HG=1\n", + "\n", + "# control the version of torch\n", + "# import torch\n", + "# if torch.__version__!='1.12.0+cu113':\n", + "# comm_line=f'pip uninstall -y torch torchvision torchaudio torchdata torchtext fastai'\n", + "# print(os.popen(comm_line).read())\n", + "# comm_line=f'pip install torch==1.12.0+cu113 torchvision==0.13.0+cu113 torchaudio==0.12.0 --extra-index-url https://download.pytorch.org/whl/cu113'\n", + "# print(os.popen(comm_line).read())\n", + "\n", + "comm_line=f'pip uninstall -y torch torchvision torchaudio torchdata torchtext fastai'\n", + "print(os.popen(comm_line).read())\n", + "comm_line=f'pip install torch==1.12.0+cu113 torchvision==0.13.0+cu113 torchaudio==0.12.0 --extra-index-url https://download.pytorch.org/whl/cu113'\n", + "print(os.popen(comm_line).read())\n", + "import torch\n", + "print('Torch version: ', torch.__version__)\n", + "\n", + "path_1 = '/opt/bin/'\n", + "dssp_file = path_1+'mkdssp'\n", + "\n", + "file_exists = os.path.exists(dssp_file)\n", + "if not (file_exists):\n", + " print('\\033[1;32m For the 1st run, ')\n", + " # ==============================================\n", + " print('a. Install omegafold...')\n", + " # install omegafold\n", + " # ref: https://github.com/HeliXonProtein/OmegaFold\n", + " !pip install git+https://github.com/HeliXonProtein/OmegaFold.git\n", + "\n", + " # time-consuming step:\n", + " # Downloading weights from https://helixon.s3.amazonaws.com/release1.pt to /root/.cache/omegafold_ckpt/model.pt\n", + " !mkdir /root/.cache/omegafold_ckpt\n", + " !wget https://helixon.s3.amazonaws.com/release1.pt -O /root/.cache/omegafold_ckpt/model.pt\n", + "\n", + " print('b. Install DSSP...')\n", + " # download an mkdssp\n", + " # ==============================================\n", + " # download things\n", + " if IF_download_from_HG!=1:\n", + " # download from dropbox: only for development\n", + " print(os.popen(f\"wget https://www.dropbox.com/s/v4azy9z9yojg1c6/mkdssp -P {path_1}\").read())\n", + " else:\n", + " # download things from huggingface\n", + " # make it simple\n", + " comm_line=f'mv Model_files/mkdssp {dssp_file}'\n", + " print(f' excuting {comm_line}')\n", + " print(os.popen(comm_line).read())\n", + "\n", + " # make it executable\n", + " !chmod u+x /opt/bin/mkdssp\n", + "\n", + "else:\n", + " print('This is not the first run... ')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "pUhFAfNfZFsW", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "pUhFAfNfZFsW", + "outputId": "0a10489a-a727-412b-a08c-f22c0c9dc3f9" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[1;32m a. on Biopython...\n", + "\u001b[1;32m b. on kornia...\n", + "Collecting kornia\n", + " Downloading kornia-0.7.0-py2.py3-none-any.whl (705 kB)\n", + " ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 705.7/705.7 kB 14.5 MB/s eta 0:00:00\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from kornia) (23.2)\n", + "Requirement already satisfied: torch>=1.9.1 in /usr/local/lib/python3.10/dist-packages (from kornia) (1.12.0+cu113)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from torch>=1.9.1->kornia) (4.5.0)\n", + "Installing collected packages: kornia\n", + "Successfully installed kornia-0.7.0\n", + "\n", + "\u001b[1;32m c. on einops...\n", + "Collecting einops\n", + " Downloading einops-0.7.0-py3-none-any.whl (44 kB)\n", + " ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 44.6/44.6 kB 1.6 MB/s eta 0:00:00\n", + "Installing collected packages: einops\n", + "Successfully installed einops-0.7.0\n", + "\n", + "Collecting einops-exts\n", + " Downloading einops_exts-0.0.4-py3-none-any.whl (3.9 kB)\n", + "Requirement already satisfied: einops>=0.4 in /usr/local/lib/python3.10/dist-packages (from einops-exts) (0.7.0)\n", + "Installing collected packages: einops-exts\n", + "Successfully installed einops-exts-0.0.4\n", + "\n", + "Collecting pytorch-warmup\n", + " Downloading pytorch_warmup-0.1.1-py3-none-any.whl (6.6 kB)\n", + "Requirement already satisfied: torch>=1.1 in /usr/local/lib/python3.10/dist-packages (from pytorch-warmup) (1.12.0+cu113)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from torch>=1.1->pytorch-warmup) (4.5.0)\n", + "Installing collected packages: pytorch-warmup\n", + "Successfully installed pytorch-warmup-0.1.1\n", + "\n", + "Collecting ema-pytorch\n", + " Downloading ema_pytorch-0.3.1-py3-none-any.whl (4.8 kB)\n", + "Collecting beartype (from ema-pytorch)\n", + " Downloading beartype-0.16.4-py3-none-any.whl (819 kB)\n", + " ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 819.1/819.1 kB 9.6 MB/s eta 0:00:00\n", + "Requirement already satisfied: torch>=1.6 in /usr/local/lib/python3.10/dist-packages (from ema-pytorch) (1.12.0+cu113)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from torch>=1.6->ema-pytorch) (4.5.0)\n", + "Installing collected packages: beartype, ema-pytorch\n", + "Successfully installed beartype-0.16.4 ema-pytorch-0.3.1\n", + "\n", + "Collecting accelerate\n", + " Downloading accelerate-0.25.0-py3-none-any.whl (265 kB)\n", + " ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 265.7/265.7 kB 5.1 MB/s eta 0:00:00\n", + "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from accelerate) (1.23.5)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from accelerate) (23.2)\n", + "Requirement already satisfied: psutil in /usr/local/lib/python3.10/dist-packages (from accelerate) (5.9.5)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.10/dist-packages (from accelerate) (6.0.1)\n", + "Requirement already satisfied: torch>=1.10.0 in /usr/local/lib/python3.10/dist-packages (from accelerate) (1.12.0+cu113)\n", + "Requirement already satisfied: huggingface-hub in /usr/local/lib/python3.10/dist-packages (from accelerate) (0.19.4)\n", + "Requirement already satisfied: safetensors>=0.3.1 in /usr/local/lib/python3.10/dist-packages (from accelerate) (0.4.1)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from torch>=1.10.0->accelerate) (4.5.0)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from huggingface-hub->accelerate) (3.13.1)\n", + "Requirement already satisfied: fsspec>=2023.5.0 in /usr/local/lib/python3.10/dist-packages (from huggingface-hub->accelerate) (2023.6.0)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from huggingface-hub->accelerate) (2.31.0)\n", + "Requirement already satisfied: tqdm>=4.42.1 in /usr/local/lib/python3.10/dist-packages (from huggingface-hub->accelerate) (4.66.1)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface-hub->accelerate) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface-hub->accelerate) (3.6)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface-hub->accelerate) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface-hub->accelerate) (2023.11.17)\n", + "Installing collected packages: accelerate\n", + "Successfully installed accelerate-0.25.0\n", + "\n", + "Collecting py3Dmol\n", + " Downloading py3Dmol-2.0.4-py2.py3-none-any.whl (12 kB)\n", + "Installing collected packages: py3Dmol\n", + "Successfully installed py3Dmol-2.0.4\n", + "\n", + "Collecting fair-esm\n", + " Downloading fair_esm-2.0.0-py3-none-any.whl (93 kB)\n", + " ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 93.1/93.1 kB 2.7 MB/s eta 0:00:00\n", + "Installing collected packages: fair-esm\n", + "Successfully installed fair-esm-2.0.0\n", + "\n", + "Collecting torchinfo\n", + " Downloading torchinfo-1.8.0-py3-none-any.whl (23 kB)\n", + "Installing collected packages: torchinfo\n", + "Successfully installed torchinfo-1.8.0\n", + "\n" + ] + } + ], + "source": [ + "#@title ####For other pip packages\n", + "# add some packages\n", + "try:\n", + " print('\\033[1;32m a. on Biopython...')\n", + " from Bio.PDB import PDBParser\n", + "except ImportError as e:\n", + " print(os.popen('pip install biopython').read())\n", + "\n", + "try:\n", + " print('\\033[1;32m b. on kornia...')\n", + " import kornia.augmentation\n", + "except ImportError as e:\n", + " print(os.popen('pip install kornia').read())\n", + "\n", + "try:\n", + " print('\\033[1;32m c. on einops...')\n", + " from einops import rearrange, repeat, reduce\n", + "except ImportError as e:\n", + " print(os.popen('pip install einops').read())\n", + "\n", + "try:\n", + " from einops_exts import rearrange_many, repeat_many, check_shape\n", + "except ImportError as e:\n", + " print(os.popen('pip install einops-exts').read())\n", + "\n", + "try:\n", + " import pytorch_warmup as warmup\n", + "except ImportError as e:\n", + " print(os.popen('pip install pytorch-warmup').read())\n", + "\n", + "try:\n", + " from ema_pytorch import EMA\n", + "except ImportError as e:\n", + " print(os.popen('pip install ema-pytorch').read())\n", + "\n", + "try:\n", + " from accelerate import Accelerator, DistributedType, DistributedDataParallelKwargs\n", + "except ImportError as e:\n", + " print(os.popen('pip install accelerate').read())\n", + "\n", + "try:\n", + " import py3Dmol\n", + "except ImportError as e:\n", + " print(os.popen('pip install py3Dmol').read())\n", + "\n", + "# added\n", + "try:\n", + " import esm\n", + "except ImportError as e:\n", + " print(os.popen('pip install fair-esm').read())\n", + "\n", + "try:\n", + " import torchinfo\n", + "except ImportError as e:\n", + " print(os.popen('pip install torchinfo').read())" + ] + }, + { + "cell_type": "markdown", + "id": "R3JeHPw9bOMQ", + "metadata": { + "id": "R3JeHPw9bOMQ" + }, + "source": [ + "### 0.2. copy src from github" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "wV1H9Bf0bYat", + "metadata": { + "id": "wV1H9Bf0bYat" + }, + "outputs": [], + "source": [ + "#@title #### Model code\n", + "\n", + "import json, time, os, sys, glob\n", + "\n", + "# # just script, no install is used\n", + "# if not os.path.isdir(\"ProteinMPNN\"):\n", + "# os.system(\"git clone -q https://github.com/dauparas/ProteinMPNN.git\")\n", + "# sys.path.append('/content/ProteinMPNN/')\n", + "\n", + "# ===================================================================\n", + "# only needed for github repository, not for huggingface\n", + "#\n", + "# if not os.path.isdir(\"ProteinMechanicsDiffusionDesign_pLDM\"):\n", + "# os.system(\"git clone -q https://github.com/Bo-Ni/ProteinMechanicsDiffusionDesign_pLDM.git\")\n", + "# # sys.path.append('/content/ProteinMechanicsDiffusionDesign_pLDM/ProteinMechanicsDiffusionDesign/')\n", + "# sys.path.append('/content/ProteinMechanicsDiffusionDesign_pLDM/')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "TBNNv-Oo7Ftw", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 104, + "referenced_widgets": [ + "2c23bccd6b9c43a3828967e6fdddc903", + "9678cabbc21540ffb6ea08a605afba75", + "b2362c4e5fc64b00a391c09d1e4e7a4c", + "aa4867c32bb5452d8135a8351dcccff0", + "adb1469b44c940faae1e411eb1a99b9d", + "eb0bd6944fdd48c1a4ac19c27ca22348", + "d7afed151ec1424e9ca260cf7258f492", + "df6da5864eb44630b814e295e4a52359", + "8e93adc8f51243b7b509838efd0c7278", + "b626ec9d0a9643848a6ec1410d0fc1a9", + "3ae4a95a3568416ab38a0276ce51ab2e" + ] + }, + "id": "TBNNv-Oo7Ftw", + "outputId": "dceca54e-2583-472e-f063-632f08be5b01" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "The cache for model files in Transformers v4.22.0 has been updated. Migrating your old cache. This is a one-time only operation. You can interrupt this and resume the migration later on by calling `transformers.utils.move_cache()`.\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "0it [00:00, ?it/s]" + ], + "application/vnd.jupyter.widget-view+json": { + "version_major": 2, + "version_minor": 0, + "model_id": "2c23bccd6b9c43a3828967e6fdddc903" + } + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "identify the device independently cuda:0\n" + ] + } + ], + "source": [ + "#@title #### Small test\n", + "# a slient test\n", + "# import ProteinMechanicsDiffusionDesign.UtilityPack as UtilityPack\n", + "# import ProteinMechanicsDiffusionDesign.DataSetPack as DataSetPack\n", + "# import ProteinMechanicsDiffusionDesign.ModelPack as ModelPack\n", + "# import ProteinMechanicsDiffusionDesign.TrainerPack as TrainerPack\n", + "# import ProteinMechanicsDiffusionDesign.PostMDPack as PostMDPack\n", + "#\n", + "import PD_pLMProbXDiff.UtilityPack as UtilityPack\n", + "import PD_pLMProbXDiff.DataSetPack as DataSetPack\n", + "import PD_pLMProbXDiff.ModelPack as ModelPack\n", + "import PD_pLMProbXDiff.TrainerPack as TrainerPack\n", + "import PD_pLMProbXDiff.PostMDPack as PostMDPack" + ] + }, + { + "cell_type": "markdown", + "id": "BRkJe9AUNRfy", + "metadata": { + "id": "BRkJe9AUNRfy" + }, + "source": [ + "### 0.3. Download the model files" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "h5l3MrGnNQuJ", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "h5l3MrGnNQuJ", + "outputId": "0d7b7e6b-6605-43e0-f3d1-2198ba2620e0" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Creating working path...\n", + "\n", + "Done.\n", + "Downing files...\n", + "excuting \n", + " mv /content/Model_files/model_pack.pickle /content/working_results/model_pack.pickle\n", + "\n", + "excuting \n", + " mv /content/Model_files/data_pack.pickle /content/working_results/data_pack.pickle\n", + "\n", + "Creating data path...\n", + "\n", + "Done.\n", + "Downing files...\n", + "excuting \n", + " mv /content/Model_files/ForTest_LE_128_From_F1_f5.pk /content/working_results/0_dataprocess_MD/ForTest_LE_128_From_F1_f5.pt\n", + "\n", + "Creating model path...\n", + "\n", + "Done.\n", + "Downing files...\n", + "excuting \n", + " mv /content/Model_files/trainer_save-model_pLDM.pt /content/working_results/1_model_SS/trainer_save-model_pLDM.pt\n", + "\n" + ] + } + ], + "source": [ + "#@title #### Set up the saved model\n", + "\n", + "# just script, no install is used\n", + "HG_model_path= '/content/Model_files/'\n", + "this_working_path = '/content/working_results/'\n", + "\n", + "if not os.path.isdir(this_working_path):\n", + " print('Creating working path...')\n", + " print(os.popen('mkdir '+this_working_path).read())\n", + " print('Done.')\n", + " print('Downing files...')\n", + "\n", + "this_file = this_working_path+'model_pack.pickle'\n", + "file_exists = os.path.exists(this_file)\n", + "if not (file_exists):\n", + " if IF_download_from_HG!=1:\n", + " # download things\n", + " this_link='https://www.dropbox.com/scl/fi/i2sull7ftjwrrzeaxo8v1/model_pack.pickle?rlkey=7wy5zynrl6m8azufklq3fy8ql&dl=0'\n", + " cmd_line = f\"wget -O {this_file} {this_link}\"\n", + " print(os.popen(cmd_line).read())\n", + " else:\n", + " # use HG\n", + " cmd_line=f'mv {HG_model_path}model_pack.pickle {this_file}'\n", + " print(f'excuting \\n {cmd_line}')\n", + " print(os.popen(cmd_line).read())\n", + "\n", + "#\n", + "this_file = this_working_path+'data_pack.pickle'\n", + "file_exists = os.path.exists(this_file)\n", + "if not (file_exists):\n", + " if IF_download_from_HG!=1:\n", + " # download things\n", + " this_link='https://www.dropbox.com/scl/fi/z7sz0q2nsjn85kyh68p86/data_pack.pickle?rlkey=bwm9fgf29ze8o516r155zg4gl&dl=0'\n", + " cmd_line = f\"wget -O {this_file} {this_link}\"\n", + " print(os.popen(cmd_line).read())\n", + " else:\n", + " # use HG\n", + " cmd_line=f'mv {HG_model_path}data_pack.pickle {this_file}'\n", + " print(f'excuting \\n {cmd_line}')\n", + " print(os.popen(cmd_line).read())\n", + "\n", + "\n", + "# add for dataset part\n", + "this_temp_path = this_working_path+'0_dataprocess_MD/'\n", + "if not os.path.isdir(this_temp_path):\n", + " print('Creating data path...')\n", + " print(os.popen('mkdir '+this_temp_path).read())\n", + " print('Done.')\n", + " print('Downing files...')\n", + "# add file if needed\n", + "#\n", + "this_file = this_working_path+'0_dataprocess_MD/'+'ForTest_LE_128_From_F1_f5.pt'\n", + "file_exists = os.path.exists(this_file)\n", + "if not (file_exists):\n", + " if IF_download_from_HG!=1:\n", + " # download things\n", + " this_link='https://www.dropbox.com/scl/fi/zn2qdcdd4apsh88xirfzj/ForTest_LE_128_From_F1_f5.pk?rlkey=oamepqanqbpzrt8lrgjknp9bk&dl=0'\n", + " cmd_line = f\"wget -O {this_file} {this_link}\"\n", + " print(os.popen(cmd_line).read())\n", + " else:\n", + " # use HG\n", + " cmd_line=f'mv {HG_model_path}ForTest_LE_128_From_F1_f5.pk {this_file}'\n", + " print(f'excuting \\n {cmd_line}')\n", + " print(os.popen(cmd_line).read())\n", + "\n", + "# add for model part\n", + "this_temp_path = this_working_path+'1_model_SS/'\n", + "if not os.path.isdir(this_temp_path):\n", + " print('Creating model path...')\n", + " print(os.popen('mkdir '+this_temp_path).read())\n", + " print('Done.')\n", + " print('Downing files...')\n", + "# add file if needed\n", + "#\n", + "this_file = this_working_path+'1_model_SS/'+'trainer_save-model_pLDM.pt'\n", + "file_exists = os.path.exists(this_file)\n", + "if not (file_exists):\n", + " if IF_download_from_HG!=1:\n", + " # download things\n", + " this_link='https://www.dropbox.com/s/09wyap14yrnoeom/trainer_save-model_pLDM.pt?dl=0'\n", + " cmd_line = f\"wget -O {this_file} {this_link}\"\n", + " print(os.popen(cmd_line).read())\n", + " else:\n", + " # use HG\n", + " cmd_line=f'mv {HG_model_path}trainer_save-model_pLDM.pt {this_file}'\n", + " print(f'excuting \\n {cmd_line}')\n", + " print(os.popen(cmd_line).read())" + ] + }, + { + "cell_type": "markdown", + "id": "jc-QOhsnGAm9", + "metadata": { + "id": "jc-QOhsnGAm9" + }, + "source": [ + "## 1. Working part" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "o6kXrcuX_LtK", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "o6kXrcuX_LtK", + "outputId": "300e3a63-7f81-49f8-ed07-1b84b54c6453" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Here is : \n", + " /content\n", + "\n", + "What we get in hardware: \n", + " Wed Dec 20 19:42:57 2023 \n", + "+---------------------------------------------------------------------------------------+\n", + "| NVIDIA-SMI 535.104.05 Driver Version: 535.104.05 CUDA Version: 12.2 |\n", + "|-----------------------------------------+----------------------+----------------------+\n", + "| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |\n", + "| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |\n", + "| | | MIG M. |\n", + "|=========================================+======================+======================|\n", + "| 0 Tesla V100-SXM2-16GB Off | 00000000:00:04.0 Off | 0 |\n", + "| N/A 33C P0 25W / 300W | 2MiB / 16384MiB | 0% Default |\n", + "| | | N/A |\n", + "+-----------------------------------------+----------------------+----------------------+\n", + " \n", + "+---------------------------------------------------------------------------------------+\n", + "| Processes: |\n", + "| GPU GI CI PID Type Process name GPU Memory |\n", + "| ID ID Usage |\n", + "|=======================================================================================|\n", + "| No running processes found |\n", + "+---------------------------------------------------------------------------------------+\n", + "\n", + "What we have in software: \n", + " Torch version: 1.12.0+cu113\n", + "Python: 3.10.12 (main, Nov 20 2023, 15:14:05) [GCC 11.4.0]\n", + "\n", + "What we have in software: \n", + " Torch version: 1.12.0+cu113\n", + "Python: 3.10.12 (main, Nov 20 2023, 15:14:05) [GCC 11.4.0]\n", + "\n", + "What hardware the software see:\n", + "cuda:0\n", + "# of GPU 1\n", + "\n" + ] + } + ], + "source": [ + "#@title ### 1.0. Check the floor\n", + "import os, sys\n", + "print('Here is : \\n', os.popen('pwd').read())\n", + "print('What we get in hardware: \\n', os.popen('nvidia-smi').read())\n", + "\n", + "import torch\n", + "print(\"What we have in software: \\n Torch version:\", torch.__version__)\n", + "print('Python: ', sys.version) # no switch case code\n", + "print()\n", + "\n", + "import torch\n", + "print(\"What we have in software: \\n Torch version:\", torch.__version__)\n", + "print('Python: ', sys.version) # no switch case code\n", + "print()\n", + "\n", + "print('What hardware the software see:')\n", + "device = torch.device(\n", + " \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n", + ")\n", + "print(device)\n", + "num_of_gpus = torch.cuda.device_count()\n", + "print(\"# of GPU\", num_of_gpus)\n", + "print()\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "SuRSZhjbGgi1", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "SuRSZhjbGgi1", + "outputId": "e5c3570b-0109-43cc-a780-1fc9a4e8c6b3" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "{\n", + " \"Running_Type\": 2,\n", + " \"Working_Mode\": 2,\n", + " \"IF_FirstRun\": 2,\n", + " \"Problem_ID\": 11,\n", + " \"Debug\": 0,\n", + " \"Debug_DataSet\": 1,\n", + " \"Debug_Model\": 1,\n", + " \"SlientRun\": 1,\n", + " \"Debug_DataPack\": 0,\n", + " \"Debug_ModelPack\": 0,\n", + " \"Debug_TrainerPack\": 0,\n", + " \"epochs\": 750,\n", + " \"print_loss_every_this_epochs\": 50,\n", + " \"sample_every_this_epochs\": 100,\n", + " \"save_model_every_this_epochs\": 50,\n", + " \"testratio\": 0.1\n", + "}\n", + "Problem type: 11\n", + "Debug mode: 0\n", + "Working mode: 2\n" + ] + } + ], + "source": [ + "#@title ### 1.1. Setup the problem\n", + "# prepare for package debugging\n", + "# for debug\n", + "import importlib\n", + "import json\n", + "import matplotlib.pyplot as plt\n", + "# import PD_pLMProbXDiff.UtilityPack as UtilityPack\n", + "# # run this when updating the package\n", + "# importlib.reload(UtilityPack)\n", + "# ===============================================\n", + "# Global control key setup\n", + "# ===============================================\n", + "# Control keys:\n", + "# This one will be directly modified for each task\n", + "CKeys = dict(\n", + " #\n", + " Running_Type=2, # 1-local:engaging cluster, 2-supercould cluster, 3-google colab, 4-local ubuntu\n", + " #\n", + " # Working_Mode=1, # 1-training, 2-sampling for test\n", + " Working_Mode=2,\n", + " #\n", + " # IF_FirstRun=1, # 1-1st run of training; otherwise, # of training run\n", + " IF_FirstRun=2, # 1-1st run of training; otherwise, # of training run\n", + " #\n", + " # 1-SecStr-ModelB, 2-MD-ModelB, 3-SecStr-ModelA, 4-MD-ModelA\n", + " # 5-SecStr-ModelB-Embdding, 6-MD-ModelB, 7-SecStr-ModelA-pLM, 8-MD-ModelA\n", + " # 9-MD-Predictor-ModelB, 10-\n", + " # 11-MD-ModelB\n", + " Problem_ID=11, # 8, # 6,\n", + " #\n", + " # Debug=1, # 1-debug mode on; add more debug keys for different blocks\n", + " Debug=0, # 1-debug mode on; add more debug keys for different blocks\n", + " #\n", + " Debug_DataSet=1,\n", + " Debug_Model=1\n", + " #\n", + " # Debug=0\n", + ")\n", + "\n", + "if CKeys['Debug']==1:\n", + " # add some\n", + " CKeys['SlientRun']=0 # 1-save figure into files; 0-show figures\n", + " # detailed debug keys\n", + " # 1. for model dimension\n", + " CKeys['Debug_DataPack']=1\n", + " CKeys['Debug_ModelPack']=1\n", + " CKeys['Debug_TrainerPack']=1\n", + " # 2. for trainer part\n", + " CKeys['Debug_DataPack']=1\n", + " CKeys['Debug_ModelPack']=0\n", + " CKeys['Debug_TrainerPack']=3\n", + " # #\n", + " # CKeys['testratio']=0.15 # for small ForcPath problem\n", + " CKeys['testratio']=0.10 # for large ForcPath problem\n", + "\n", + "else:\n", + " # for real working run\n", + " CKeys['SlientRun']=1\n", + " #\n", + " CKeys['Debug_DataPack'] = 0\n", + " CKeys['Debug_ModelPack'] = 0\n", + " CKeys['Debug_TrainerPack'] = 0 # 2 # 1\n", + " # add some for training\n", + " CKeys['epochs'] = 4000-3250 # 1000 # 200\n", + " CKeys['print_loss_every_this_epochs']=50 # 5\n", + " CKeys['sample_every_this_epochs']=100 # 50 # 20\n", + " CKeys['save_model_every_this_epochs']=50 # 20\n", + " # #\n", + " # # add some for training\n", + " # CKeys['epochs'] = 2000 # 1000 # 200\n", + " # CKeys['print_loss_every_this_epochs']=20 # 5\n", + " # CKeys['sample_every_this_epochs']=50 # 50 # 20\n", + " # CKeys['save_model_every_this_epochs']=50 # 20\n", + " #\n", + " # CKeys['testratio']=0.15 # for small ForcPath problem\n", + " CKeys['testratio']=0.10 # for large ForcPath problem\n", + " #\n", + " # # add some for training\n", + " # CKeys['epochs'] = 4 # 1000 # 200\n", + " # CKeys['print_loss_every_this_epochs']=1 # 5\n", + " # CKeys['sample_every_this_epochs']=1 # 50 # 20\n", + " # CKeys['save_model_every_this_epochs']=2 # 20\n", + "\n", + "# for check\n", + "print(json.dumps(CKeys, indent=4))\n", + "\n", + "\n", + "# Problem type:\n", + "print('Problem type: ', CKeys['Problem_ID'])\n", + "print('Debug mode: ', CKeys['Debug'])\n", + "print('Working mode: ', CKeys['Working_Mode'])\n", + "\n", + "\n", + "# ===========================================================\n", + "# Parameter key:\n", + "# ===========================================================\n", + "#\n", + "PKeys = {}\n", + "# define this one according the running environment\n", + "# add more if needed\n", + "# if CKeys['Running_Type']==1 or CKeys['Running_Type']==4:\n", + "# if CKeys['Running_Type']==1:\n", + "#\n", + "#\n", + "root_path = '/home/gridsan/bni/Test_ground/jupyter/1_git_project/sort_pdb_database_0/Local_Store/'\n", + "if CKeys['Debug']==1:\n", + " # PKeys['prefix']='../Local_Store/For_16_0/'\n", + " # use the absolute path for transformability\n", + " PKeys['prefix']=root_path+'For_20_0/'\n", + "\n", + "if CKeys['Debug']!=1:\n", + " # PKeys['prefix']='../Local_Store/For_16_1/'\n", + " PKeys['prefix']=root_path+'For_20_1/'\n", + " PKeys['prefix']='/home/gridsan/bni/16_WG_git_sort_pdb_database_0/11_pLMProb_Diff_SMD_ModelB_embed_640/0_Training/'\n", + " # add one for google colab\n", + " PKeys['prefix']=this_working_path # '/content/11_pLMProb_Diff_SMD_ModelB_embed_640/0_Training/'\n", + "\n", + "# store the data pack after processing\n", + "PKeys['pk_data_pack']=PKeys['prefix']+'data_pack.pickle'\n", + "PKeys['pk_model_pack']=PKeys['prefix']+'model_pack.pickle'\n", + "# PKeys[]\n", + "# print(CKeys['Running_Type'])\n", + "# print(CKeys['Working_Mode']==1 and CKeys['IF_FirstRun']==1)\n", + "# print(PKeys['prefix'])\n", + "\n", + "#\n", + "# clean EVERYTHING in the dir if 1st\n", + "#\n", + "if CKeys['Working_Mode']==1 and CKeys['IF_FirstRun']==1:\n", + " if os.path.exists(PKeys['prefix']):\n", + " cmd_line=f\"rm -r {PKeys['prefix']}\"\n", + " print(\"clean the slade...\")\n", + " print(f\"excute {cmd_line}\")\n", + " os.popen(cmd_line).read()\n", + " #\n", + " # create dir for working space\n", + " UtilityPack.create_path(PKeys['prefix'])\n", + "# ========================================================================\n", + "# prepare the csv files\n", + "# ========================================================================\n", + "\n", + "if CKeys['Problem_ID']==1 or CKeys['Problem_ID']==3 \\\n", + "or CKeys['Problem_ID']==5 or CKeys['Problem_ID']==7:\n", + "# SS_csv_file = PKeys['prefix']+'PROTEIN_Mar18_2022_SECSTR_ALL.csv'\n", + "\n", + "# file_exists = os.path.exists(SS_csv_file)\n", + "# if not (file_exists):\n", + "# print('Downing the csv file...')\n", + "# print(os.popen(f\"wget https://www.dropbox.com/s/7o7s15w9qr6z76y/PROTEIN_Mar18_2022_SECSTR_ALL.csv -P {PKeys['prefix']}\").read())\n", + "# print('Done.')\n", + "# else:\n", + "# print(\"Already there\")\n", + " # +\n", + " # SS_csv_file = '/home/gridsan/bni/Test_ground/jupyter/1_git_project/sort_pdb_database_0/Local_Store/'+'PROTEIN_Mar18_2022_SECSTR_ALL.csv'\n", + " SS_csv_file = root_path+'Local_Store/'+'PROTEIN_Mar18_2022_SECSTR_ALL.csv'\n", + "\n", + "if CKeys['Problem_ID']==2 or CKeys['Problem_ID']==4 \\\n", + "or CKeys['Problem_ID']==6 or CKeys['Problem_ID']==8 \\\n", + "or CKeys['Problem_ID']==11:\n", + " # to be copied locally\n", + " # MD_smo_csv_file = '/home/gridsan/bni/Test_ground/jupyter/1_git_project/sort_pdb_database_0/Local_Store/For_1/ForTrain_recon_BSDB_LE_64_smd_disp_forc_df_smo.csv'\n", + " # first debug with LE_64, to be update into LE_128\n", + " MD_smo_csv_file = root_path+'For_1/ForTrain_recon_BSDB_LE_64_smd_disp_forc_df_smo.csv'\n", + " MD_smo_pk_file = root_path+'For_1/ForTrain_recon_BSDB_LE_64_smd_disp_forc_df_smo_shared.pk'\n", + " # into LE_128\n", + " MD_smo_pk_file = root_path+'For_1/ForTrain_recon_BSDB_LE_128_smd_disp_forc_df_smo.pk'" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "yI_BcJcx9nVJ", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "yI_BcJcx9nVJ", + "outputId": "ca48d1ad-54e3-4322-f3f1-f45508da3ce0" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "On Problem: 11\n", + "/content/working_results/\n", + "{'Running_Type': 2, 'Working_Mode': 2, 'IF_FirstRun': 2, 'Problem_ID': 11, 'Debug': 0, 'Debug_DataSet': 1, 'Debug_Model': 1, 'SlientRun': 1, 'Debug_DataPack': 0, 'Debug_ModelPack': 0, 'Debug_TrainerPack': 0, 'epochs': 750, 'print_loss_every_this_epochs': 50, 'sample_every_this_epochs': 100, 'save_model_every_this_epochs': 50, 'testratio': 0.1}\n", + "This is not the first run\n", + "Load back in the data packages...\n", + "Done.\n", + "{'data_dir': '/content/working_results/0_dataprocess_MD/', 'min_AA_seq_len': 0, 'max_AA_seq_len': 128, 'max_Force_cap': 1000, 'X_Key': 'sample_FORCEpN_data', 'tokenizer_X': None, 'tokenizer_y': None, 'Xnormfac': 750.0, 'ynormfac': 1.0, 'batch_size': 256, 'testset_ratio': 0.15, 'maxdata': 99999999991000, 'ESM-2_Model': 'esm2_t30_150M_UR50D', 'image_channels': 33}\n", + "/content/working_results/\n" + ] + } + ], + "source": [ + "#@title ### 1.2. Handle the dataset\n", + "\n", + "import pickle\n", + "import numpy as np\n", + "import pandas as pd\n", + "# import PD_pLMProbXDiff.DataSetPack as DataSetPack\n", + "# importlib.reload(DataSetPack)\n", + "print('On Problem: ', CKeys['Problem_ID'])\n", + "print(this_working_path)\n", + "# on the sec_str csv file: SecStr\n", + "# try to convey all para via one key\n", + "# ====================================================\n", + "# add some new keys for dataset\n", + "# ====================================================\n", + "# for data washing: only for 1st training cycle\n", + "if CKeys['Working_Mode']==1 and CKeys['IF_FirstRun']==1:\n", + "\n", + " if CKeys['Problem_ID']==1:\n", + " pass\n", + " # print(\"1\")\n", + " # # +++++++++++++++++++++++++++++++++++++\n", + " # # SecStr as input seq\n", + " # DataKeys={}\n", + " # DataKeys['data_dir']=PKeys['prefix']+'0_dataprocess_SS/'\n", + " # # screening rules\n", + " # DataKeys['min_AA_seq_len']=0\n", + " # DataKeys['max_AA_seq_len']=128\n", + " # # X and Y processing\n", + " # DataKeys['Xnormfac']=9.\n", + " # DataKeys['ynormfac']=21.\n", + " # DataKeys['tokenizer_X']=None\n", + " # DataKeys['tokenizer_y']=None\n", + " # # + for AA embending using ESM\n", + " # DataKeys['ESM-2_Model']='esm2_t33_650M_UR50D'\n", + " # # deliver\n", + " # DataKeys['batch_size']=256\n", + " # DataKeys['batch_size']=200\n", + " # DataKeys['testset_ratio']=0.1\n", + " # DataKeys['maxdata']=99999999999999999\n", + " # # add the folder for Data part\n", + " # UtilityPack.create_path(DataKeys['data_dir'])\n", + "\n", + " elif CKeys['Problem_ID']==2:\n", + " pass\n", + " print(\"2\")\n", + "# # ++++++++++++++++++++++++++++++++++++++\n", + "# # MD record as the input seq\n", + "# #\n", + "# # try to convey all para via one key\n", + "# DataKeys={}\n", + "# # ======================================\n", + "# # keys for \"screen_dataset_MD\"\n", + "# DataKeys['data_dir']=PKeys['prefix']+'0_dataprocess_MD/'\n", + "# # add the folder\n", + "# UtilityPack.create_path(DataKeys['data_dir'])\n", + "\n", + "# # screening rules\n", + "# DataKeys['min_AA_seq_len']=0\n", + "# DataKeys['max_AA_seq_len']=64\n", + "# DataKeys['max_Force_cap']=1000\n", + "# # special ones\n", + "# # change text arr into np arr\n", + "# DataKeys['arr_key']=[\n", + "# 'posi_data','pull_data','forc_data',\n", + "# 'gap_data','normalized_gap_data',\n", + "# 'pull_gap_data', 'normalized_pull_gap_data',\n", + "# 'sample_NormPullGap_data','sample_FORCEpN_data']\n", + "\n", + "# df_raw, protein_df = DataSetPack.screen_dataset_MD(\n", + "# file_path=MD_smo_csv_file,\n", + "# PKeys=DataKeys, # to be updated\n", + "# CKeys=CKeys,\n", + "# )\n", + "\n", + "# # save the dataframe\n", + "# pd.to_pickle(protein_df, DataKeys['data_dir']+'protein_df.pk')\n", + "# pd.to_pickle(df_raw, DataKeys['data_dir']+'df_raw.pk')\n", + "\n", + "# # ======================================\n", + "# # keys for 2nd function\n", + "# DataKeys['X_Key']='sample_FORCEpN_data' # or 'Max_Smo_Force'\n", + "# #\n", + "# DataKeys['tokenizer_X']=None # will not be used\n", + "# DataKeys['tokenizer_y']=None # to be created\n", + "# DataKeys['Xnormfac'] = np.max(protein_df['Max_Smo_Force'])\n", + "# print('Normalization factor for force: ', DataKeys['Xnormfac'])\n", + "# DataKeys['ynormfac']=21. # old force diffusion model 22.\n", + "# #\n", + "# DataKeys['batch_size']=256\n", + "# DataKeys['testset_ratio']=0.15\n", + "# DataKeys['maxdata']=99999999991000\n", + "\n", + " elif CKeys['Problem_ID']==3:\n", + " pass\n", + " # print(\"3\")\n", + " # # +++++++++++++++++++++++++++++++++++++\n", + " # # SecStr as input seq\n", + " # DataKeys={}\n", + " # DataKeys['data_dir']=PKeys['prefix']+'0_dataprocess_SS_ModelA/'\n", + " # # screening rules\n", + " # DataKeys['min_AA_seq_len']=0\n", + " # DataKeys['max_AA_seq_len']=64 # 128\n", + " # DataKeys['max_text_len']=8\n", + " # # X and Y processing\n", + " # DataKeys['Xnormfac']=1.\n", + " # DataKeys['ynormfac']=22. # 21.\n", + " # DataKeys['tokenizer_X']=None\n", + " # DataKeys['tokenizer_y']=None\n", + " # # deliver\n", + " # DataKeys['batch_size']=512\n", + " # # for debug purpose\n", + " # # DataKeys['batch_size']=1\n", + " # DataKeys['testset_ratio']= 0.1\n", + " # DataKeys['maxdata']=99999999999999999\n", + " # # add the folder for Data part\n", + " # UtilityPack.create_path(DataKeys['data_dir'])\n", + "\n", + " elif CKeys['Problem_ID']==4:\n", + " pass\n", + "\n", + "# print(\"4: input text condition, output sequence...\")\n", + "# # ++++++++++++++++++++++++++++++++++++++\n", + "# # MD record as the input seq\n", + "# #\n", + "# # try to convey all para via one key\n", + "# DataKeys={}\n", + "# # ======================================\n", + "# # keys for \"screen_dataset_MD\"\n", + "# DataKeys['data_dir']=PKeys['prefix']+'0_dataprocess_MD/'\n", + "# # add the folder\n", + "# UtilityPack.create_path(DataKeys['data_dir'])\n", + "\n", + "# # screening rules\n", + "# DataKeys['min_AA_seq_len']=0\n", + "# DataKeys['max_AA_seq_len']=64\n", + "# DataKeys['max_text_len']=2\n", + "# DataKeys['max_Force_cap']=1000\n", + "# # special ones\n", + "# # change text arr into np arr\n", + "# DataKeys['arr_key']=[\n", + "# 'posi_data','pull_data','forc_data',\n", + "# 'gap_data','normalized_gap_data',\n", + "# 'pull_gap_data', 'normalized_pull_gap_data',\n", + "# 'sample_NormPullGap_data','sample_FORCEpN_data']\n", + "\n", + "# df_raw, protein_df = DataSetPack.screen_dataset_MD(\n", + "# file_path=MD_smo_csv_file,\n", + "# PKeys=DataKeys, # to be updated\n", + "# CKeys=CKeys,\n", + "# )\n", + "\n", + "# # save the dataframe\n", + "# pd.to_pickle(protein_df, DataKeys['data_dir']+'protein_df.pk')\n", + "# pd.to_pickle(df_raw, DataKeys['data_dir']+'df_raw.pk')\n", + "\n", + "# # ======================================\n", + "# # keys for 2nd function\n", + "# DataKeys['X_Key']=['Max_Smo_Force','Int_Smo_ForcPull'] # 'sample_FORCEpN_data' # or 'Max_Smo_Force'\n", + "# #\n", + "# DataKeys['tokenizer_X']=None # will not be used\n", + "# DataKeys['tokenizer_y']=None # to be created\n", + "# #\n", + "# print('Normalization factor for force: ',\n", + "# np.max(protein_df['Max_Smo_Force']))\n", + "# print('Normalization factor for toughness: ',\n", + "# np.max(protein_df['Int_Smo_ForcPull']))\n", + "# #\n", + "# DataKeys['Xnormfac'] = np.array([\n", + "# np.max(protein_df['Max_Smo_Force']),\n", + "# np.max(protein_df['Int_Smo_ForcPull'])\n", + "# ])\n", + "# #\n", + "# DataKeys['ynormfac']=21. # old force diffusion model 22.\n", + "# #\n", + "# DataKeys['batch_size']=256\n", + "# DataKeys['testset_ratio']=0.15\n", + "# DataKeys['maxdata']=99999999991000\n", + "\n", + " # /////////////////////////////////////////////////////////////\n", + " # try embedding\n", + " # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\n", + " elif CKeys['Problem_ID']==5:\n", + " pass\n", + "\n", + "# print(\"5\")\n", + "# # +++++++++++++++++++++++++++++++++++++\n", + "# # SecStr as input seq\n", + "# DataKeys={}\n", + "# DataKeys['data_dir']=PKeys['prefix']+'0_dataprocess_SS/'\n", + "# # screening rules\n", + "# DataKeys['min_AA_seq_len']=0\n", + "# DataKeys['max_AA_seq_len']=128\n", + "# # X and Y processing\n", + "# DataKeys['Xnormfac']=9.\n", + "# DataKeys['ynormfac']=1 # for ESM # 21.\n", + "# DataKeys['tokenizer_X']=None\n", + "# DataKeys['tokenizer_y']=None\n", + "# # + for AA embending using ESM\n", + "# DataKeys['ESM-2_Model']='esm2_t33_650M_UR50D'\n", + "# # add for embedding space\n", + "# DataKeys['image_channels']=1280\n", + "# # deliver\n", + "# DataKeys['batch_size']=256\n", + "# DataKeys['batch_size']=256 # 0 # 200\n", + "# DataKeys['testset_ratio']=CKeys['testratio'] # 0.1\n", + "# DataKeys['maxdata']=99999999999999999\n", + "\n", + "# # add the folder for Data part\n", + "# UtilityPack.create_path(DataKeys['data_dir'])\n", + " #\n", + " elif CKeys['Problem_ID']==6:\n", + " print(\"6, input MD ForcePath, output AA sequence\")\n", + " # ++++++++++++++++++++++++++++++++++++++\n", + " # MD record as the tokenized input seq\n", + " #\n", + " # try to convey all para via one key\n", + " DataKeys={}\n", + " # ======================================\n", + " # keys for \"screen_dataset_MD\"\n", + " DataKeys['data_dir']=PKeys['prefix']+'0_dataprocess_MD/'\n", + " # add the folder\n", + " UtilityPack.create_path(DataKeys['data_dir'])\n", + "\n", + " # screening rules\n", + " DataKeys['min_AA_seq_len']=0\n", + " # DataKeys['max_AA_seq_len']=64\n", + " DataKeys['max_AA_seq_len']=128\n", + " DataKeys['max_Force_cap']=1000\n", + "# # ---------------------------------------\n", + "# # special ones\n", + "# # change text arr into np arr\n", + "# DataKeys['arr_key']=[\n", + "# 'posi_data','pull_data','forc_data',\n", + "# 'gap_data','normalized_gap_data',\n", + "# 'pull_gap_data', 'normalized_pull_gap_data',\n", + "# 'sample_NormPullGap_data','sample_FORCEpN_data']\n", + "\n", + "# df_raw, protein_df = DataSetPack.screen_dataset_MD(\n", + "# csv_file=MD_smo_csv_file,\n", + "# pk_file=None,\n", + "# PKeys=DataKeys, # to be updated\n", + "# CKeys=CKeys,\n", + "# )\n", + " # ++++++++++++++++++++++++++++++++++++++\n", + " df_raw, protein_df = DataSetPack.screen_dataset_MD(\n", + " csv_file=None,\n", + " pk_file=MD_smo_pk_file,\n", + " PKeys=DataKeys, # to be updated\n", + " CKeys=CKeys,\n", + " )\n", + "\n", + " # save the dataframe\n", + " pd.to_pickle(protein_df, DataKeys['data_dir']+'protein_df.pk')\n", + " pd.to_pickle(df_raw, DataKeys['data_dir']+'df_raw.pk')\n", + "\n", + " # ======================================\n", + " # keys for 2nd function\n", + " DataKeys['X_Key']='sample_FORCEpN_data' # or 'Max_Smo_Force'\n", + " #\n", + " DataKeys['tokenizer_X']=None # will not be used\n", + " DataKeys['tokenizer_y']=None # to be created\n", + " # think about this: update this one if necessary\n", + " # DataKeys['Xnormfac'] = np.max(protein_df['Max_Smo_Force'])\n", + " DataKeys['Xnormfac'] = 750.\n", + "\n", + " print('Normalization factor for force: ', DataKeys['Xnormfac'])\n", + " DataKeys['ynormfac']=1. # not used as esm is used # 21. # old force diffusion model 22.\n", + " #\n", + " DataKeys['batch_size']=256\n", + " DataKeys['testset_ratio']=0.15\n", + " DataKeys['maxdata']=99999999991000\n", + " # ++ for pLM\n", + " # for AA embending using ESM\n", + " DataKeys['ESM-2_Model']='esm2_t33_650M_UR50D'\n", + " # add for embedding space\n", + " DataKeys['image_channels']=1280\n", + " #\n", + " DataKeys['ESM-2_Model']='esm2_t12_35M_UR50D'\n", + " DataKeys['image_channels']=480\n", + "\n", + "\n", + " elif CKeys['Problem_ID']==7:\n", + " pass\n", + " # print(\"7\")\n", + " # # +++++++++++++++++++++++++++++++++++++\n", + " # # SecStr text as input seq\n", + " # DataKeys={}\n", + " # DataKeys['data_dir']=PKeys['prefix']+'0_dataprocess_SS_ModelA/'\n", + " # # screening rules\n", + " # DataKeys['min_AA_seq_len']=0\n", + " # DataKeys['max_AA_seq_len']=64 # 128\n", + " # DataKeys['max_text_len']=8\n", + " # # X and Y processing\n", + " # DataKeys['Xnormfac']=1.\n", + " # DataKeys['ynormfac']=1. # for ESM # 21. 22. # 21.\n", + " # DataKeys['tokenizer_X']=None\n", + " # DataKeys['tokenizer_y']=None\n", + " # # deliver\n", + " # DataKeys['batch_size']=512\n", + " # # for debug purpose\n", + " # # DataKeys['batch_size']=1\n", + " # DataKeys['testset_ratio']= CKeys['testratio'] # 0.1\n", + " # DataKeys['maxdata']=99999999999999999\n", + " # # + for AA embending using ESM\n", + " # DataKeys['ESM-2_Model']='esm2_t33_650M_UR50D'\n", + " # # add for embedding space\n", + " # DataKeys['image_channels']=1280\n", + " # #\n", + " # # add the folder for Data part\n", + " # UtilityPack.create_path(DataKeys['data_dir'])\n", + "\n", + " elif CKeys['Problem_ID']==8:\n", + " #\n", + " print(\"8: input text condition, output sequence...\")\n", + " # ++++++++++++++++++++++++++++++++++++++\n", + " # MD record as the input seq\n", + " #\n", + " # try to convey all para via one key\n", + " DataKeys={}\n", + " # ======================================\n", + " # keys for \"screen_dataset_MD\"\n", + " DataKeys['data_dir']=PKeys['prefix']+'0_dataprocess_MD/'\n", + " # add the folder\n", + " UtilityPack.create_path(DataKeys['data_dir'])\n", + "\n", + " # screening rules\n", + " DataKeys['min_AA_seq_len']=0\n", + " DataKeys['max_AA_seq_len']=64\n", + " DataKeys['max_AA_seq_len']=128\n", + " DataKeys['max_text_len']=2\n", + " DataKeys['max_Force_cap']=1000\n", + "# # ---------------------------------------------------------\n", + "# # special ones\n", + "# # change text arr into np arr\n", + "# DataKeys['arr_key']=[\n", + "# 'posi_data','pull_data','forc_data',\n", + "# 'gap_data','normalized_gap_data',\n", + "# 'pull_gap_data', 'normalized_pull_gap_data',\n", + "# 'sample_NormPullGap_data','sample_FORCEpN_data']\n", + "\n", + "# df_raw, protein_df = DataSetPack.screen_dataset_MD(\n", + "# # # --\n", + "# # file_path=MD_smo_csv_file,\n", + "# # ++\n", + "# csv_file=MD_smo_csv_file,\n", + "# pk_file=None,\n", + "# PKeys=DataKeys, # to be updated\n", + "# CKeys=CKeys,\n", + "# )\n", + " # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n", + " df_raw, protein_df = DataSetPack.screen_dataset_MD(\n", + " csv_file=None,\n", + " pk_file=MD_smo_pk_file,\n", + " PKeys=DataKeys, # to be updated\n", + " CKeys=CKeys,\n", + " )\n", + "\n", + " # save the dataframe\n", + " pd.to_pickle(protein_df, DataKeys['data_dir']+'protein_df.pk')\n", + " pd.to_pickle(df_raw, DataKeys['data_dir']+'df_raw.pk')\n", + "\n", + " # ======================================\n", + " # keys for 2nd function\n", + " DataKeys['X_Key']=['Max_Smo_Force','Int_Smo_ForcPull'] # 'sample_FORCEpN_data' # or 'Max_Smo_Force'\n", + " #\n", + " DataKeys['tokenizer_X']=None # will not be used\n", + " DataKeys['tokenizer_y']=None # will not be used # to be created\n", + " #\n", + " print('Normalization factor for force: ',\n", + " np.max(protein_df['Max_Smo_Force']))\n", + " print('Normalization factor for toughness: ',\n", + " np.max(protein_df['Int_Smo_ForcPull']))\n", + " #\n", + " DataKeys['Xnormfac'] = np.array([\n", + " np.max(protein_df['Max_Smo_Force']),\n", + " np.max(protein_df['Int_Smo_ForcPull'])\n", + " ])\n", + " #\n", + " DataKeys['ynormfac']=1.0 # not used in esm # 21. # old force diffusion model 22.\n", + " #\n", + " DataKeys['batch_size']=256\n", + " DataKeys['testset_ratio']=CKeys['testratio'] # 0.15\n", + " DataKeys['maxdata']=99999999991000\n", + " # + for AA embending using ESM\n", + " DataKeys['ESM-2_Model']='esm2_t33_650M_UR50D'\n", + " # add for embedding space\n", + " DataKeys['image_channels']=1280\n", + "\n", + " elif CKeys['Problem_ID']==11:\n", + " # copied from Problem_ID=6\n", + " #\n", + " print(\"11, input MD ForcePath, output AA sequence\")\n", + " # ++++++++++++++++++++++++++++++++++++++\n", + " # MD record as the tokenized input seq\n", + " #\n", + " # try to convey all para via one key\n", + " DataKeys={}\n", + " # ======================================\n", + " # keys for \"screen_dataset_MD\"\n", + " DataKeys['data_dir']=PKeys['prefix']+'0_dataprocess_MD/'\n", + " # add the folder\n", + " UtilityPack.create_path(DataKeys['data_dir'])\n", + "\n", + " # screening rules\n", + " DataKeys['min_AA_seq_len']=0\n", + " # DataKeys['max_AA_seq_len']=64\n", + " DataKeys['max_AA_seq_len']=128\n", + " DataKeys['max_Force_cap']=1000\n", + "# # ---------------------------------------\n", + "# # special ones\n", + "# # change text arr into np arr\n", + "# DataKeys['arr_key']=[\n", + "# 'posi_data','pull_data','forc_data',\n", + "# 'gap_data','normalized_gap_data',\n", + "# 'pull_gap_data', 'normalized_pull_gap_data',\n", + "# 'sample_NormPullGap_data','sample_FORCEpN_data']\n", + "\n", + "# df_raw, protein_df = DataSetPack.screen_dataset_MD(\n", + "# csv_file=MD_smo_csv_file,\n", + "# pk_file=None,\n", + "# PKeys=DataKeys, # to be updated\n", + "# CKeys=CKeys,\n", + "# )\n", + " # ++++++++++++++++++++++++++++++++++++++\n", + " df_raw, protein_df = DataSetPack.screen_dataset_MD(\n", + " csv_file=None,\n", + " pk_file=MD_smo_pk_file,\n", + " PKeys=DataKeys, # to be updated\n", + " CKeys=CKeys,\n", + " )\n", + "\n", + " # save the dataframe\n", + " pd.to_pickle(protein_df, DataKeys['data_dir']+'protein_df.pk')\n", + " pd.to_pickle(df_raw, DataKeys['data_dir']+'df_raw.pk')\n", + "\n", + " # ======================================\n", + " # keys for 2nd function\n", + " DataKeys['X_Key']='sample_FORCEpN_data' # or 'Max_Smo_Force'\n", + " #\n", + " DataKeys['tokenizer_X']=None # will not be used\n", + " DataKeys['tokenizer_y']=None # to be created\n", + " # think about this: update this one if necessary\n", + " # DataKeys['Xnormfac'] = np.max(protein_df['Max_Smo_Force'])\n", + " DataKeys['Xnormfac'] = 750.\n", + "\n", + " print('Normalization factor for force: ', DataKeys['Xnormfac'])\n", + " DataKeys['ynormfac']=1. # not used as esm is used # 21. # old force diffusion model 22.\n", + " #\n", + " DataKeys['batch_size']=256\n", + " DataKeys['testset_ratio']=0.15\n", + " DataKeys['maxdata']=99999999991000\n", + " # ++ for pLM\n", + " # for AA embending using ESM\n", + " DataKeys['ESM-2_Model']='esm2_t33_650M_UR50D'\n", + " # add for embedding space\n", + " # DataKeys['image_channels']=1280\n", + " #\n", + " # DataKeys['ESM-2_Model']='esm2_t12_35M_UR50D'\n", + " # # DataKeys['image_channels']=480\n", + " #\n", + " # DataKeys['ESM-2_Model']='esm2_t36_3B_UR50D'\n", + " # DataKeys['image_channels']=2560\n", + " #\n", + " DataKeys['ESM-2_Model']='esm2_t30_150M_UR50D'\n", + " # DataKeys['image_channels']=640\n", + "\n", + " # only use the probability part\n", + " DataKeys['image_channels']=33\n", + "\n", + " else:\n", + " print('No Problem Type found...')\n", + "# else:\n", + "# # load back if there is anything generated in the 1st run\n", + "# if CKeys['Problem_ID']==2 or CKeys['Problem_ID']==6:\n", + "# protein_df = pd.read_pickle(DataKeys['data_dir']+'protein_df.pk')\n", + "# df_raw = pd.read_pickle(DataKeys['data_dir']+'df_raw.pk')\n", + "print(CKeys)\n", + "\n", + "\n", + "# ====================================================\n", + "# convert into datasets\n", + "# ====================================================\n", + "if CKeys['Working_Mode']==1 and CKeys['IF_FirstRun']==1:\n", + " if CKeys['Problem_ID']==1:\n", + " pass\n", + " # train_loader, \\\n", + " # train_loader_noshuffle, \\\n", + " # test_loader, \\\n", + " # tokenizer_y, tokenizer_X = DataSetPack.load_data_set_SS_InSeqToOuSeq(\n", + " # file_path=SS_csv_file,\n", + " # PKeys=DataKeys, # to be updated\n", + " # CKeys=CKeys,\n", + " # )\n", + "\n", + " elif CKeys['Problem_ID']==2:\n", + " pass\n", + " # train_loader, train_loader_noshuffle, \\\n", + " # test_loader, tokenizer_y, tokenizer_X = DataSetPack.load_data_set_from_df_SMD(\n", + " # protein_df,\n", + " # PKeys=DataKeys, # to be updated\n", + " # CKeys=CKeys,\n", + " # )\n", + "\n", + " elif CKeys['Problem_ID']==3:\n", + " pass\n", + " # train_loader, train_loader_noshuffle, \\\n", + " # test_loader,tokenizer_y, tokenizer_X = DataSetPack.load_data_set_seq2seq_SecStr_ModelA (\n", + " # file_path=SS_csv_file, # 'PROTEIN_Mar18_2022_SECSTR_ALL.csv',\n", + " # PKeys=DataKeys, # to be updated\n", + " # CKeys=CKeys,\n", + " # )\n", + "\n", + " elif CKeys['Problem_ID']==4:\n", + " pass\n", + " # train_loader, train_loader_noshuffle, \\\n", + " # test_loader,tokenizer_y, tokenizer_X = DataSetPack.load_data_set_text2seq_MD_ModelA (\n", + " # protein_df,\n", + " # PKeys=DataKeys, # to be updated\n", + " # CKeys=CKeys,\n", + " # )\n", + "\n", + " # ///////////////////////////////////////////////////////////////\n", + " # add embedding cases\n", + " # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\n", + " elif CKeys['Problem_ID']==5:\n", + " pass\n", + " # train_loader, \\\n", + " # train_loader_noshuffle, \\\n", + " # test_loader, \\\n", + " # tokenizer_y, \\\n", + " # tokenizer_X = DataSetPack.load_data_set_SS_InSeqToOuSeq_pLM(\n", + " # file_path=SS_csv_file,\n", + " # PKeys=DataKeys, # to be updated\n", + " # CKeys=CKeys,\n", + " # )\n", + " # # this will triger the following downloading\n", + " # # Downloading: \"https://dl.fbaipublicfiles.com/fair-esm/models/esm2_t33_650M_UR50D.pt\" to /home/gridsan/bni/.cache/torch/hub/checkpoints/esm2_t33_650M_UR50D.pt\n", + " # # excute the following if without internet on the node\n", + " # # 1 $ wget https://dl.fbaipublicfiles.com/fair-esm/models/esm2_t33_650M_UR50D.pt -O /home/gridsan/bni/.cache/torch/hub/checkpoints/esm2_t33_650M_UR50D.pt\n", + " # # 2 $ wget https://dl.fbaipublicfiles.com/fair-esm/regression/esm2_t33_650M_UR50D-contact-regression.pt -O /home/gridsan/bni/.cache/torch/hub/checkpoints/esm2_t33_650M_UR50D-contact-regression.pt\n", + "\n", + " # add if needed\n", + " elif CKeys['Problem_ID']==6:\n", + "\n", + " train_loader, \\\n", + " train_loader_noshuffle, \\\n", + " test_loader, \\\n", + " tokenizer_y, \\\n", + " tokenizer_X = DataSetPack.load_data_set_from_df_SMD_pLM(\n", + " protein_df,\n", + " PKeys=DataKeys, # to be updated\n", + " CKeys=CKeys,\n", + " )\n", + "\n", + " elif CKeys['Problem_ID']==7:\n", + " pass\n", + " # train_loader, \\\n", + " # train_loader_noshuffle, \\\n", + " # test_loader, \\\n", + " # tokenizer_y, \\\n", + " # tokenizer_X = DataSetPack.load_data_set_seq2seq_SecStr_ModelA_pLM (\n", + " # file_path=SS_csv_file, # 'PROTEIN_Mar18_2022_SECSTR_ALL.csv',\n", + " # PKeys=DataKeys, # to be updated\n", + " # CKeys=CKeys,\n", + " # )\n", + "\n", + " elif CKeys['Problem_ID']==8:\n", + "\n", + " train_loader, \\\n", + " train_loader_noshuffle, \\\n", + " test_loader,\\\n", + " tokenizer_y, \\\n", + " tokenizer_X = DataSetPack.load_data_set_text2seq_MD_ModelA_pLM (\n", + " protein_df,\n", + " PKeys=DataKeys, # to be updated\n", + " CKeys=CKeys,\n", + " )\n", + "\n", + " elif CKeys['Problem_ID']==11:\n", + "\n", + " train_loader, \\\n", + " train_loader_noshuffle, \\\n", + " test_loader, \\\n", + " tokenizer_y, \\\n", + " tokenizer_X = DataSetPack.load_data_set_from_df_SMD_pLM(\n", + " protein_df,\n", + " PKeys=DataKeys, # to be updated\n", + " CKeys=CKeys,\n", + " )\n", + "\n", + " elif CKeys['Problem_ID']==12:\n", + " pass\n", + "\n", + " else:\n", + " print('No Problem Type found...')\n", + "\n", + " print(\"==========================================\")\n", + " print(\"Save the datasets ...\")\n", + " print(\"==========================================\")\n", + " # save the dataset for for the 1st run\n", + " data_pack = {}\n", + " data_pack['train_loader']=train_loader\n", + " data_pack['train_loader_noshuffle']=train_loader_noshuffle\n", + " data_pack['test_loader']=test_loader\n", + " data_pack['tokenizer_X']=tokenizer_X\n", + " data_pack['tokenizer_y']=tokenizer_y\n", + " # keys\n", + " data_pack['DataKeys']=DataKeys\n", + " # data_pack['CKeys']=CKeys\n", + " data_pack['PKeys']=PKeys\n", + " with open(PKeys['pk_data_pack'], 'wb') as handle:\n", + " pickle.dump(data_pack, handle, protocol=pickle.HIGHEST_PROTOCOL)\n", + "\n", + "else: # work both for training and testing\n", + "\n", + " print('This is not the first run')\n", + " print('Load back in the data packages...')\n", + " with open(PKeys['pk_data_pack'], 'rb') as handle:\n", + " data_pack = pickle.load(handle)\n", + " # deliver the results\n", + " train_loader=data_pack['train_loader']\n", + " train_loader_noshuffle=data_pack['train_loader_noshuffle']\n", + " test_loader=data_pack['test_loader']\n", + " tokenizer_X=data_pack['tokenizer_X']\n", + " tokenizer_y=data_pack['tokenizer_y']\n", + " # keys (create or update)\n", + " DataKeys=data_pack['DataKeys']\n", + " # ++ for colab, need to update the path part\n", + " DataKeys['data_dir']=this_working_path+'0_dataprocess_MD/'\n", + " # ++\n", + " # CKeys=data_pack['CKeys']\n", + " PKeys=data_pack['PKeys']\n", + " # ++ for colab, need to update the path part\n", + " PKeys['prefix']=this_working_path\n", + " PKeys['pk_data_pack']=this_working_path+'data_pack.pickle'\n", + " PKeys['pk_model_pack']=this_working_path+'model_pack.pickle'\n", + " # ++\n", + " # add some for specific problem\n", + " if CKeys['Problem_ID']==2 or CKeys['Problem_ID']==6 \\\n", + " or CKeys['Problem_ID']==11:\n", + " pass\n", + " # skip\n", + " # protein_df = pd.read_pickle(DataKeys['data_dir']+'protein_df.pk')\n", + " # df_raw = pd.read_pickle(DataKeys['data_dir']+'df_raw.pk')\n", + " print('Done.')\n", + "\n", + "\n", + "print(DataKeys)\n", + "print(this_working_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "TwXmEpWhjWcI", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TwXmEpWhjWcI", + "outputId": "80ee7d00-84a1-4d72-d6e1-c69a127d3aec" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "tokenizer_X: None\n", + "tokenizer_y: None\n", + "Xnormfac: 750.0\n", + "ynormfac: 1.0\n" + ] + } + ], + "source": [ + "#@title ### 1.2.1 Prepare for de novo conditions\n", + "\n", + "# add a block to handle the De Novo force shape\n", + "# idea: pick to to mix them\n", + "# if CKeys['Working_Mode']==1 and CKeys['IF_FirstRun']==1 and CKeys['Problem_ID']==2:\n", + "if CKeys['Working_Mode']==1 and CKeys['Problem_ID']==2:\n", + " print( protein_df.keys() )\n", + " # pick the Max_Smo_Force max and min\n", + " pick_id_0 = protein_df['Max_Smo_Force'].idxmax()\n", + " pick_id_1 = protein_df['Max_Smo_Force'].idxmin()\n", + " print(protein_df['Max_Smo_Force'].idxmax())\n", + " print(protein_df['Max_Smo_Force'].idxmin())\n", + "\n", + " fig = plt.figure(figsize=(24,16),dpi=200)\n", + " fig, ax0 = plt.subplots()\n", + " for ii in [pick_id_0, pick_id_1]:\n", + " ax0.plot(\n", + " protein_df['sample_NormPullGap_data'][ii],\n", + " protein_df['sample_FORCE_data'][ii],\n", + " alpha=0.1,\n", + " # color=\"green\",label='simplified data',\n", + " # linestyle='None',marker='^'\n", + " )\n", + " ax0.scatter(\n", + " protein_df['NPullGap_for_MaxSmoF'][ii],\n", + " protein_df['Max_Smo_Force'][ii],\n", + " )\n", + " plt.xlabel('Normalized distance btw pulling ends')\n", + " plt.ylabel('Force (pF)')\n", + " outname = DataKeys['data_dir']+'CSV_6_PickMaxMinF_SMD_sim_Dist.jpg'\n", + " if CKeys['SlientRun'] ==1:\n", + " plt.savefig(outname, dpi=200)\n", + " else:\n", + " plt.show()\n", + " plt.close()\n", + "\n", + "elif CKeys['Working_Mode']==1 and CKeys['Problem_ID']==5:\n", + " #\n", + " pass\n", + " #\n", + "elif CKeys['Working_Mode']==1 and CKeys['Problem_ID']==6:\n", + " print( protein_df.keys() )\n", + " # pick the Max_Smo_Force max and min\n", + " pick_id_0 = protein_df['Max_Smo_Force'].idxmax()\n", + " pick_id_1 = protein_df['Max_Smo_Force'].idxmin()\n", + " # print(protein_df['Max_Smo_Force'].idxmax())\n", + " # print(protein_df['Max_Smo_Force'].idxmin())\n", + " print(f\"Max Peak Force id: {pick_id_0}\")\n", + " print(f\"Min Peak Force id: {pick_id_1}\")\n", + "\n", + " fig = plt.figure(figsize=(24,16),dpi=200)\n", + " fig, ax0 = plt.subplots()\n", + " for ii in [pick_id_0, pick_id_1]:\n", + " ax0.plot(\n", + " protein_df['sample_NormPullGap_data'][ii],\n", + " protein_df['sample_FORCE_data'][ii],\n", + " alpha=0.1,\n", + " # color=\"green\",label='simplified data',\n", + " # linestyle='None',marker='^'\n", + " )\n", + " ax0.scatter(\n", + " protein_df['NPullGap_for_MaxSmoF'][ii],\n", + " protein_df['Max_Smo_Force'][ii],\n", + " )\n", + " plt.xlabel('Normalized distance btw pulling ends')\n", + " plt.ylabel('Force (pF)')\n", + " outname = DataKeys['data_dir']+'CSV_6_PickMaxMinF_SMD_sim_Dist.jpg'\n", + " if CKeys['SlientRun'] ==1:\n", + " plt.savefig(outname, dpi=200)\n", + " else:\n", + " plt.show()\n", + " plt.close()\n", + "\n", + "elif CKeys['Working_Mode']==1 and CKeys['Problem_ID']==11:\n", + " # skipped\n", + " pass\n", + " # print( protein_df.keys() )\n", + " # # pick the Max_Smo_Force max and min\n", + " # pick_id_0 = protein_df['Max_Smo_Force'].idxmax()\n", + " # pick_id_1 = protein_df['Max_Smo_Force'].idxmin()\n", + " # # print(protein_df['Max_Smo_Force'].idxmax())\n", + " # # print(protein_df['Max_Smo_Force'].idxmin())\n", + " # print(f\"Max Peak Force id: {pick_id_0}\")\n", + " # print(f\"Min Peak Force id: {pick_id_1}\")\n", + "\n", + " # fig = plt.figure(figsize=(24,16),dpi=200)\n", + " # fig, ax0 = plt.subplots()\n", + " # for ii in [pick_id_0, pick_id_1]:\n", + " # ax0.plot(\n", + " # protein_df['sample_NormPullGap_data'][ii],\n", + " # protein_df['sample_FORCE_data'][ii],\n", + " # alpha=0.1,\n", + " # # color=\"green\",label='simplified data',\n", + " # # linestyle='None',marker='^'\n", + " # )\n", + " # ax0.scatter(\n", + " # protein_df['NPullGap_for_MaxSmoF'][ii],\n", + " # protein_df['Max_Smo_Force'][ii],\n", + " # )\n", + " # plt.xlabel('Normalized distance btw pulling ends')\n", + " # plt.ylabel('Force (pF)')\n", + " # outname = DataKeys['data_dir']+'CSV_6_PickMaxMinF_SMD_sim_Dist.jpg'\n", + " # if CKeys['SlientRun'] ==1:\n", + " # plt.savefig(outname, dpi=200)\n", + " # else:\n", + " # plt.show()\n", + " # plt.close()\n", + "# a quick check\n", + "print('tokenizer_X: ', tokenizer_X)\n", + "print('tokenizer_y: ', tokenizer_y)\n", + "print('Xnormfac: ', DataKeys['Xnormfac'])\n", + "print('ynormfac: ', DataKeys['ynormfac'])\n", + "\n", + "if CKeys['Debug']==1:\n", + "\n", + " if CKeys['Debug_DataPack']==1:\n", + " # uppack to check\n", + " print('Len of train loader:', len(train_loader))\n", + " print('Len of test loader:', len(test_loader))\n", + " ii=-1\n", + " # for item in train_loader:\n", + " for item in test_loader:\n", + " ii += 1\n", + " if ii<1:\n", + " print('Len of 1st batch item: ', len(item))\n", + " this_item = item\n", + " else:\n", + " pass\n", + "\n", + " # on mini-batch\n", + " print('Batch size: ', DataKeys['batch_size'])\n", + " print('Seq len: ', DataKeys['max_AA_seq_len'])\n", + " print('X.dim: ', this_item[0].shape) # Condition: (Batch, Condi)\n", + " print('y_data.dim: ', this_item[1].shape) # AASequenc: (Batch, AACode)\n", + " #\n", + " # # print(this_item[0][0,:]*DataKeys['Xnormfac'])\n", + " # # print(this_item[1][0,:]*DataKeys['ynormfac'])\n", + " print(this_item[0][0,:])\n", + " # print(torch.FloatTensor(DataKeys['Xnormfac']))\n", + " # print(this_item[0][0,:]*torch.FloatTensor(DataKeys['Xnormfac']))\n", + "\n", + "if CKeys['Debug']==1:\n", + "\n", + " if CKeys['Debug_DataPack']==1:\n", + "\n", + " if CKeys['Problem_ID']==8 or CKeys['Problem_ID']==7:\n", + "\n", + " print (this_item[0][0,:])\n", + " print (this_item[0][0,:]*DataKeys['Xnormfac'])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "4lE_XT0bjtAV", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4lE_XT0bjtAV", + "outputId": "d9f78c42-4139-4216-ac9d-07af60cfe477" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "==================================================\n", + "load in the MODEL key from the previous storage\n", + "==================================================\n", + "This is not the first run\n", + "Load back in the model packages...\n", + "Done.\n", + "128\n", + "33\n", + "33\n", + "33\n", + "{\n", + " \"dim\": 256,\n", + " \"text_embed_dim\": 544,\n", + " \"num_resnet_blocks\": 1,\n", + " \"cond_dim\": 512,\n", + " \"num_image_tokens\": null,\n", + " \"num_time_tokens\": null,\n", + " \"learned_sinu_pos_emb_dim\": null,\n", + " \"out_dim\": null,\n", + " \"dim_mults\": [\n", + " 1,\n", + " 2,\n", + " 4,\n", + " 8\n", + " ],\n", + " \"cond_images_channels\": 33,\n", + " \"channels\": 33,\n", + " \"channels_out\": 33,\n", + " \"attn_dim_head\": 64,\n", + " \"attn_heads\": 8,\n", + " \"ff_mult\": 2.0,\n", + " \"lowres_cond\": false,\n", + " \"layer_attns\": [\n", + " false,\n", + " true,\n", + " true,\n", + " false\n", + " ],\n", + " \"layer_attns_depth\": 1,\n", + " \"layer_attns_add_text_cond\": true,\n", + " \"attend_at_middle\": true,\n", + " \"layer_cross_attns\": [\n", + " false,\n", + " true,\n", + " true,\n", + " false\n", + " ],\n", + " \"use_linear_attn\": false,\n", + " \"use_linear_cross_attn\": false,\n", + " \"cond_on_text\": true,\n", + " \"max_text_len\": 128,\n", + " \"init_dim\": null,\n", + " \"resnet_groups\": 8,\n", + " \"init_conv_kernel_size\": 7,\n", + " \"init_cross_embed\": false,\n", + " \"init_cross_embed_kernel_sizes\": [\n", + " 3,\n", + " 7,\n", + " 15\n", + " ],\n", + " \"cross_embed_downsample\": false,\n", + " \"cross_embed_downsample_kernel_sizes\": [\n", + " 2,\n", + " 4\n", + " ],\n", + " \"attn_pool_text\": true,\n", + " \"attn_pool_num_latents\": 32,\n", + " \"dropout\": 0.0,\n", + " \"memory_efficient\": false,\n", + " \"init_conv_to_final_conv_residual\": false,\n", + " \"use_global_context_attn\": true,\n", + " \"scale_skip_connection\": true,\n", + " \"final_resnet_block\": true,\n", + " \"final_conv_kernel_size\": 3,\n", + " \"cosine_sim_attn\": true,\n", + " \"self_cond\": false,\n", + " \"combine_upsample_fmaps\": true,\n", + " \"pixel_shuffle_upsample\": false,\n", + " \"beginning_and_final_conv_present\": null\n", + "}\n", + "{'timesteps': (96,), 'dim': 256, 'pred_dim': 33, 'loss_type': 0, 'elucidated': True, 'padding_idx': 0, 'cond_dim': None, 'text_embed_dim': None, 'input_tokens': None, 'sequence_embed': None, 'embed_dim_position': None, 'max_text_len': 128, 'cond_images_channels': 33, 'max_length': 128, 'device': device(type='cuda', index=0)}\n", + "33\n", + "33\n", + "33\n", + "33\n", + "33\n", + "\n", + "256\n", + "256\n", + "--------------------------------------------\n", + "On OneD_Unet...\n", + "--------------------------------------------\n", + "256 33\n", + "Working unet part model: \n", + "Total parameters: 264376242 trainable parameters: 264376242\n", + "--------------------------------------------\n", + "On whole model...\n", + "--------------------------------------------\n", + "Model B: Generative protein diffusion model, residue-based\n", + "Using condition as the initial sequence\n", + "Use conditioning image during training....\n", + "Loss type: 0\n", + "Channels in=33, channels out=33\n", + "Test on cast_model_parameters...\n", + "False\n", + "False\n", + "None\n", + "33\n", + "33\n", + "256 33\n", + "cpu\n", + "Total working model: \n", + "Total parameters: 262527570 trainable parameters: 262527570\n", + "Recasted unet inside the tot one only: \n", + "Total parameters: 262521266 trainable parameters: 262521266\n", + "--------------------------------------------\n", + "On trainer...\n", + "--------------------------------------------\n" + ] + } + ], + "source": [ + "#@title ### 1.3 Model building\n", + "\n", + "# import PD_pLMProbXDiff.ModelPack as ModelPack\n", + "# #\n", + "# import PD_pLMProbXDiff.TrainerPack as TrainerPack\n", + "# #\n", + "# importlib.reload(ModelPack)\n", + "# importlib.reload(TrainerPack)\n", + "\n", + "if CKeys['Working_Mode']==1 and CKeys['IF_FirstRun']==1:\n", + " # this is a trining mode\n", + " if CKeys['Problem_ID']==1:\n", + " pass\n", + "# # this is 1st run....\n", + "# # +++++++++++++++++++++++++++++++++++++\n", + "# # SecStr as input seq\n", + "# ModelKeys={}\n", + "# # storage\n", + "# ModelKeys['model_dir']=PKey['prefix']+'1_model_SS/'\n", + "# # create the folder\n", + "# print(\"Creating the model dir...\")\n", + "# UtilityPack.create_path(ModelKeys['model_dir'])\n", + "# # secondary folders\n", + "# ModelKeys['model_dir_sample']=ModelKeys['model_dir']+'0_mid_sample/'\n", + "# UtilityPack.create_path(ModelKeys['model_dir_sample'])\n", + "# ModelKeys['model_dir_model']=ModelKeys['model_dir']+'1_store_model/'\n", + "# UtilityPack.create_path(ModelKeys['model_dir_model'])\n", + "\n", + "# # for UNet\n", + "# ModelKeys['dim']=256 # dim for UNet\n", + "# ModelKeys['text_embed_dim'] = 512\n", + "# ModelKeys['embed_dim_position']=32\n", + "# ModelKeys['text_embed_dim']=ModelKeys['text_embed_dim']+ModelKeys['embed_dim_position']\n", + "# ModelKeys['cond_dim'] = 512\n", + "# ModelKeys['cond_images_channels']=1\n", + "# ModelKeys['max_text_len']=DataKeys['max_AA_seq_len'] # this is about text condi\n", + "# # for Imagen\n", + "# ModelKeys['pred_dim']=1 # for sequence, =1\n", + "# ModelKeys['diff_timesteps']=(96,)\n", + "# ModelKeys['loss_type']=0 # MSE\n", + "# ModelKeys['elucidated']=True #\n", + "# ModelKeys['padding_idx']=0\n", + "# ModelKeys['max_length']=DataKeys['max_AA_seq_len'] # max seq len\n", + "# ModelKeys['device']=device\n", + "# #\n", + "# # buckets for Model building\n", + "# ModelKeys['UNet']={}\n", + "# ModelKeys['Imagen']={}\n", + "# # ++++++++++++++++++++++++++++++++++++++++++++++++++\n", + "# write_PK_UNet=dict()\n", + "# write_PK_UNet['dim']=ModelKeys['dim'] # 256\n", + "# write_PK_UNet['text_embed_dim']=ModelKeys['text_embed_dim'] # 512+32\n", + "# write_PK_UNet['num_resnet_blocks']=1\n", + "# write_PK_UNet['cond_dim']=ModelKeys['cond_dim'] #this is where text embeddings are projected to...\n", + "# # write_PK_UNet['num_image_tokens']=None # using the default value\n", + "# # write_PK_UNet['num_time_tokens']=None # using the default\n", + "# # write_PK_UNet['learned_sinu_pos_emb_dim']=None\n", + "# # write_PK_UNet['out_dim']=None\n", + "# write_PK_UNet['dim_mults']=(1, 2, 4, 8)\n", + "\n", + "# write_PK_UNet['cond_images_channels']=ModelKeys['cond_images_channels']\n", + "# write_PK_UNet['channels']=1\n", + "# write_PK_UNet['channels_out']=1\n", + "\n", + "# write_PK_UNet['attn_dim_head']=64\n", + "# write_PK_UNet['attn_heads']=8\n", + "# write_PK_UNet['ff_mult']=2.\n", + "# write_PK_UNet['lowres_cond']=False # for cascading diffusion - https://cascaded-diffusion.github.io/\n", + "\n", + "# write_PK_UNet['layer_attns']=(False, True, True, False)\n", + "# write_PK_UNet['layer_attns_depth']=1\n", + "# write_PK_UNet['layer_attns_add_text_cond']=True # whether to condition the self-attention blocks with the text embeddings, as described in Appendix D.3.1\n", + "# write_PK_UNet['attend_at_middle']=True # whether to have a layer of attention at the bottleneck (can turn off for higher resolution in cascading DDPM, before bringing in efficient attention)\n", + "# write_PK_UNet['layer_cross_attns']=(False, True, True, False)\n", + "# write_PK_UNet['use_linear_attn']=False\n", + "# write_PK_UNet['use_linear_cross_attn']=False\n", + "\n", + "# write_PK_UNet['cond_on_text']=True\n", + "# write_PK_UNet['max_text_len']=ModelKeys['max_text_len'] # need to check this one\n", + "# # ModelKeys['UNet']['init_dim']=None\n", + "# write_PK_UNet['resnet_groups']=8\n", + "# write_PK_UNet['init_conv_kernel_size']=7 # kernel size of initial conv, if not using cross embed\n", + "# write_PK_UNet['init_cross_embed']=False #TODO - fix ouput size calcs for conv1d\n", + "# write_PK_UNet['init_cross_embed_kernel_sizes']=(3, 7, 15)\n", + "# write_PK_UNet['cross_embed_downsample']=False\n", + "# write_PK_UNet['cross_embed_downsample_kernel_sizes']=(2, 4)\n", + "\n", + "# write_PK_UNet['attn_pool_text']=True\n", + "# write_PK_UNet['attn_pool_num_latents']=32 #perceiver model latents\n", + "# write_PK_UNet['dropout']=0.\n", + "# write_PK_UNet['memory_efficient']=False\n", + "# write_PK_UNet['init_conv_to_final_conv_residual']=False\n", + "\n", + "# write_PK_UNet['use_global_context_attn']=True\n", + "# write_PK_UNet['scale_skip_connection']=True\n", + "# write_PK_UNet['final_resnet_block']=True\n", + "# write_PK_UNet['final_conv_kernel_size']=3\n", + "\n", + "# write_PK_UNet['cosine_sim_attn']=True\n", + "# write_PK_UNet['self_cond']=False\n", + "# write_PK_UNet['combine_upsample_fmaps']=True # combine feature maps from all upsample blocks, used in unet squared successfully\n", + "# write_PK_UNet['pixel_shuffle_upsample']=False # may address checkboard artifacts\n", + "# # write_PK_UNet['beginning_and_final_conv_present']=None # use default\n", + "# ModelKeys['UNet']=UtilityPack.prepare_UNet_keys(write_PK_UNet)\n", + "# # +++++++++++++++++++++++++++++++++++++++++++++++++++++\n", + "# # beyond UNet, for Whole model, all keys\n", + "# # \"None\" means defult value on function definition\n", + "# write_PK_Imagen=dict()\n", + "\n", + "# write_PK_Imagen['timesteps']=ModelKeys['diff_timesteps']\n", + "# write_PK_Imagen['dim']=ModelKeys['dim']\n", + "# write_PK_Imagen['pred_dim']=ModelKeys['pred_dim']\n", + "# write_PK_Imagen['loss_type']=ModelKeys['loss_type'] # 0 # MSE\n", + "# write_PK_Imagen['elucidated']=ModelKeys['elucidated'] # True\n", + "# write_PK_Imagen['padding_idx']=ModelKeys['padding_idx'] # 0 # need to check\n", + "# # write_PK_Imagen['cond_dim']=None # use default\n", + "# # write_PK_Imagen['text_embed_dim']=None\n", + "# # write_PK_Imagen['input_tokens']=None\n", + "# # write_PK_Imagen['sequence_embed']=None\n", + "# # write_PK_Imagen['embed_dim_position']=None\n", + "# write_PK_Imagen['max_text_len']=ModelKeys['max_text_len']\n", + "# write_PK_Imagen['cond_images_channels']=ModelKeys['pred_dim']\n", + "# write_PK_Imagen['max_length']=ModelKeys['max_length']\n", + "# write_PK_Imagen['device']=ModelKeys['device']\n", + "\n", + "# # extend it to a full key\n", + "# ModelKeys['Imagen']=UtilityPack.prepare_ModelB_keys(write_PK_Imagen)\n", + "\n", + " elif CKeys['Problem_ID']==2:\n", + " pass\n", + "# # this is 1st run....\n", + "# # +++++++++++++++++++++++++++++++++++++\n", + "# # SecStr as input seq\n", + "# ModelKeys={}\n", + "# # storage\n", + "# ModelKeys['model_dir']=PKeys['prefix']+'1_model_SS/'\n", + "# # create the folder\n", + "# print(\"Creating the model dir...\")\n", + "# UtilityPack.create_path(ModelKeys['model_dir'])\n", + "# # secondary folders\n", + "# ModelKeys['model_dir_sample']=ModelKeys['model_dir']+'0_mid_sample/'\n", + "# UtilityPack.create_path(ModelKeys['model_dir_sample'])\n", + "# ModelKeys['model_dir_model']=ModelKeys['model_dir']+'1_store_model/'\n", + "# UtilityPack.create_path(ModelKeys['model_dir_model'])\n", + "\n", + "# # for UNet\n", + "# ModelKeys['dim']=256 # dim for UNet\n", + "# ModelKeys['text_embed_dim'] = 512\n", + "# ModelKeys['embed_dim_position']=32\n", + "# ModelKeys['text_embed_dim']=ModelKeys['text_embed_dim']+ModelKeys['embed_dim_position']\n", + "# ModelKeys['cond_dim'] = 512\n", + "# ModelKeys['cond_images_channels']=1\n", + "# ModelKeys['max_text_len']=DataKeys['max_AA_seq_len'] # this is about text condi\n", + "# # for Imagen\n", + "# ModelKeys['pred_dim']=1 # for sequence, =1\n", + "# ModelKeys['diff_timesteps']=(96,)\n", + "# ModelKeys['loss_type']=0 # MSE\n", + "# ModelKeys['elucidated']=True #\n", + "# ModelKeys['padding_idx']=0\n", + "# ModelKeys['max_length']=DataKeys['max_AA_seq_len'] # max seq len\n", + "# ModelKeys['device']=device\n", + "# #\n", + "# # buckets for Model building\n", + "# ModelKeys['UNet']={}\n", + "# ModelKeys['Imagen']={}\n", + "# # ++++++++++++++++++++++++++++++++++++++++++++++++++\n", + "# write_PK_UNet=dict()\n", + "# write_PK_UNet['dim']=ModelKeys['dim'] # 256\n", + "# write_PK_UNet['text_embed_dim']=ModelKeys['text_embed_dim'] # 512+32\n", + "# write_PK_UNet['num_resnet_blocks']=1\n", + "# write_PK_UNet['cond_dim']=ModelKeys['cond_dim'] #this is where text embeddings are projected to...\n", + "# # write_PK_UNet['num_image_tokens']=None # using the default value\n", + "# # write_PK_UNet['num_time_tokens']=None # using the default\n", + "# # write_PK_UNet['learned_sinu_pos_emb_dim']=None\n", + "# # write_PK_UNet['out_dim']=None\n", + "# write_PK_UNet['dim_mults']=(1, 2, 4, 8)\n", + "\n", + "# write_PK_UNet['cond_images_channels']=ModelKeys['cond_images_channels']\n", + "# write_PK_UNet['channels']=1\n", + "# write_PK_UNet['channels_out']=1\n", + "\n", + "# write_PK_UNet['attn_dim_head']=64\n", + "# write_PK_UNet['attn_heads']=8\n", + "# write_PK_UNet['ff_mult']=2.\n", + "# write_PK_UNet['lowres_cond']=False # for cascading diffusion - https://cascaded-diffusion.github.io/\n", + "\n", + "# write_PK_UNet['layer_attns']=(False, True, True, False)\n", + "# write_PK_UNet['layer_attns_depth']=1\n", + "# write_PK_UNet['layer_attns_add_text_cond']=True # whether to condition the self-attention blocks with the text embeddings, as described in Appendix D.3.1\n", + "# write_PK_UNet['attend_at_middle']=True # whether to have a layer of attention at the bottleneck (can turn off for higher resolution in cascading DDPM, before bringing in efficient attention)\n", + "# write_PK_UNet['layer_cross_attns']=(False, True, True, False)\n", + "# write_PK_UNet['use_linear_attn']=False\n", + "# write_PK_UNet['use_linear_cross_attn']=False\n", + "\n", + "# write_PK_UNet['cond_on_text']=True\n", + "# write_PK_UNet['max_text_len']=ModelKeys['max_text_len'] # need to check this one\n", + "# # ModelKeys['UNet']['init_dim']=None\n", + "# write_PK_UNet['resnet_groups']=8\n", + "# write_PK_UNet['init_conv_kernel_size']=7 # kernel size of initial conv, if not using cross embed\n", + "# write_PK_UNet['init_cross_embed']=False #TODO - fix ouput size calcs for conv1d\n", + "# write_PK_UNet['init_cross_embed_kernel_sizes']=(3, 7, 15)\n", + "# write_PK_UNet['cross_embed_downsample']=False\n", + "# write_PK_UNet['cross_embed_downsample_kernel_sizes']=(2, 4)\n", + "\n", + "# write_PK_UNet['attn_pool_text']=True\n", + "# write_PK_UNet['attn_pool_num_latents']=32 #perceiver model latents\n", + "# write_PK_UNet['dropout']=0.\n", + "# write_PK_UNet['memory_efficient']=False\n", + "# write_PK_UNet['init_conv_to_final_conv_residual']=False\n", + "\n", + "# write_PK_UNet['use_global_context_attn']=True\n", + "# write_PK_UNet['scale_skip_connection']=True\n", + "# write_PK_UNet['final_resnet_block']=True\n", + "# write_PK_UNet['final_conv_kernel_size']=3\n", + "\n", + "# write_PK_UNet['cosine_sim_attn']=True\n", + "# write_PK_UNet['self_cond']=False\n", + "# write_PK_UNet['combine_upsample_fmaps']=True # combine feature maps from all upsample blocks, used in unet squared successfully\n", + "# write_PK_UNet['pixel_shuffle_upsample']=False # may address checkboard artifacts\n", + "# # write_PK_UNet['beginning_and_final_conv_present']=None # use default\n", + "# ModelKeys['UNet']=UtilityPack.prepare_UNet_keys(write_PK_UNet)\n", + "# # +++++++++++++++++++++++++++++++++++++++++++++++++++++\n", + "# # beyond UNet, for Whole model, all keys\n", + "# # \"None\" means defult value on function definition\n", + "# write_PK_Imagen=dict()\n", + "\n", + "# write_PK_Imagen['timesteps']=ModelKeys['diff_timesteps']\n", + "# write_PK_Imagen['dim']=ModelKeys['dim']\n", + "# write_PK_Imagen['pred_dim']=ModelKeys['pred_dim']\n", + "# write_PK_Imagen['loss_type']=ModelKeys['loss_type'] # 0 # MSE\n", + "# write_PK_Imagen['elucidated']=ModelKeys['elucidated'] # True\n", + "# write_PK_Imagen['padding_idx']=ModelKeys['padding_idx'] # 0 # need to check\n", + "# # write_PK_Imagen['cond_dim']=None # use default\n", + "# # write_PK_Imagen['text_embed_dim']=None\n", + "# # write_PK_Imagen['input_tokens']=None\n", + "# # write_PK_Imagen['sequence_embed']=None\n", + "# # write_PK_Imagen['embed_dim_position']=None\n", + "# write_PK_Imagen['max_text_len']=ModelKeys['max_text_len']\n", + "# write_PK_Imagen['cond_images_channels']=ModelKeys['cond_images_channels']\n", + "# write_PK_Imagen['max_length']=ModelKeys['max_length']\n", + "# write_PK_Imagen['device']=ModelKeys['device']\n", + "\n", + "# # extend it to a full key\n", + "# ModelKeys['Imagen']=UtilityPack.prepare_ModelB_keys(write_PK_Imagen)\n", + "# # to be defined\n", + "\n", + " elif CKeys['Problem_ID']==3:\n", + " pass\n", + "\n", + "# ModelKeys={}\n", + "# # storage\n", + "# ModelKeys['model_dir']=PKeys['prefix']+'1_model_SS/'\n", + "# # create the folder\n", + "# print(\"Creating the model dir...\")\n", + "# UtilityPack.create_path(ModelKeys['model_dir'])\n", + "# # secondary folders\n", + "# ModelKeys['model_dir_sample']=ModelKeys['model_dir']+'0_mid_sample/'\n", + "# UtilityPack.create_path(ModelKeys['model_dir_sample'])\n", + "# ModelKeys['model_dir_model']=ModelKeys['model_dir']+'1_store_model/'\n", + "# UtilityPack.create_path(ModelKeys['model_dir_model'])\n", + "\n", + "# # for UNet\n", + "# ModelKeys['dim']=768 # dim for UNet\n", + "# # for debug\n", + "# ModelKeys['dim']=256 # dim for UNet: GPU stat: 256:16093MiB;\n", + "# #\n", + "# ModelKeys['text_embed_dim']=512-128\n", + "# ModelKeys['embed_dim_position']=128\n", + "# # ! this is for UNet, not for Imagen\n", + "# ModelKeys['text_embed_dim']=ModelKeys['text_embed_dim']+ModelKeys['embed_dim_position']\n", + "# ModelKeys['cond_dim']=512\n", + "# # ModelKeys['embed_dim_position']=128\n", + "# # ModelKeys['text_embed_dim']=ModelKeys['cond_dim']-ModelKeys['embed_dim_position']\n", + "# # !!! Need to check this one = 1 or not\n", + "# ModelKeys['cond_images_channels']=0 # 1\n", + "# # !!! Need to check this one: should it be 8 or 64?\n", + "# ModelKeys['max_text_len']= DataKeys['max_text_len'] # DataKeys['max_AA_seq_len'] # 8 # this is about text condi\n", + "\n", + "# # for Imagen\n", + "# ModelKeys['pred_dim']=1 # for sequence, =1\n", + "# ModelKeys['diff_timesteps']=(96) # (96,)\n", + "# ModelKeys['loss_type']=0 # MSE\n", + "# ModelKeys['elucidated']=True #\n", + "# ModelKeys['padding_idx']=0\n", + "# ModelKeys['max_length']=DataKeys['max_AA_seq_len']\n", + "# ModelKeys['device']=device\n", + "# #\n", + "# # baskets for Model building\n", + "# ModelKeys['UNet']={}\n", + "# ModelKeys['Imagen']={}\n", + "# # ++++++++++++++++++++++++++++++++++++++\n", + "# # prepare the Unet Key\n", + "# write_PK_UNet=dict()\n", + "# # used ones\n", + "# write_PK_UNet['dim']=ModelKeys['dim']\n", + "# write_PK_UNet['text_embed_dim']=ModelKeys['text_embed_dim']\n", + "# write_PK_UNet['num_resnet_blocks']=1\n", + "# write_PK_UNet['cond_dim']=ModelKeys['cond_dim'] #this is where text embeddings are projected to...\n", + "# # write_PK_UNet['num_image_tokens']=None # using the default value\n", + "# # write_PK_UNet['num_time_tokens']=None # using the default\n", + "# # write_PK_UNet['learned_sinu_pos_emb_dim']=None\n", + "# # write_PK_UNet['out_dim']=None\n", + "# write_PK_UNet['dim_mults']=(1, 2, 4, 8)\n", + "\n", + "# write_PK_UNet['cond_images_channels']=ModelKeys['cond_images_channels']\n", + "# write_PK_UNet['channels']=ModelKeys['pred_dim']\n", + "# write_PK_UNet['channels_out']=ModelKeys['pred_dim']\n", + "\n", + "# write_PK_UNet['attn_dim_head']=64\n", + "# write_PK_UNet['attn_heads']=8\n", + "# write_PK_UNet['ff_mult']=2.\n", + "# write_PK_UNet['lowres_cond']=False # for cascading diffusion - https://cascaded-diffusion.github.io/\n", + "\n", + "\n", + "# write_PK_UNet['layer_attns']=(False, True, True, False)\n", + "# write_PK_UNet['layer_attns_depth']=1\n", + "# write_PK_UNet['layer_attns_add_text_cond']=True # whether to condition the self-attention blocks with the text embeddings, as described in Appendix D.3.1\n", + "# write_PK_UNet['attend_at_middle']=True # whether to have a layer of attention at the bottleneck (can turn off for higher resolution in cascading DDPM, before bringing in efficient attention)\n", + "# write_PK_UNet['layer_cross_attns']=(False, True, True, False)\n", + "# write_PK_UNet['use_linear_attn']=False\n", + "# write_PK_UNet['use_linear_cross_attn']=False\n", + "\n", + "# write_PK_UNet['cond_on_text'] = True\n", + "# # !!! Need to check this: 63, Imagen used a different one\n", + "# write_PK_UNet['max_text_len'] = DataKeys['max_AA_seq_len'] # ModelKeys['max_text_len']\n", + "# # write_PK_UNet['init_dim'] = None\n", + "# write_PK_UNet['resnet_groups'] = 8\n", + "# write_PK_UNet['init_conv_kernel_size'] =7 # kernel size of initial conv, if not using cross embed\n", + "# write_PK_UNet['init_cross_embed'] = False #TODO - fix ouput size calcs for conv1d\n", + "# write_PK_UNet['init_cross_embed_kernel_sizes'] = (3, 7, 15)\n", + "# write_PK_UNet['cross_embed_downsample'] = False\n", + "# write_PK_UNet['cross_embed_downsample_kernel_sizes'] = (2, 4)\n", + "\n", + "# write_PK_UNet['attn_pool_text'] = True\n", + "# write_PK_UNet['attn_pool_num_latents'] = 32 #32, #perceiver model latents\n", + "# write_PK_UNet['dropout'] = 0.\n", + "# write_PK_UNet['memory_efficient'] = False\n", + "# write_PK_UNet['init_conv_to_final_conv_residual'] = False\n", + "\n", + "# write_PK_UNet['use_global_context_attn'] = True\n", + "# write_PK_UNet['scale_skip_connection'] = True\n", + "# write_PK_UNet['final_resnet_block'] = True\n", + "# write_PK_UNet['final_conv_kernel_size'] = 3\n", + "\n", + "# write_PK_UNet['cosine_sim_attn'] = True\n", + "# write_PK_UNet['self_cond'] = False\n", + "# write_PK_UNet['combine_upsample_fmaps'] = True # combine feature maps from all upsample blocks, used in unet squared successfully\n", + "# write_PK_UNet['pixel_shuffle_upsample'] = False # may address checkboard artifacts\n", + "# # write_PK_UNet['beginning_and_final_conv_present']=None # use default\n", + "# #\n", + "# ModelKeys['UNet']=UtilityPack.prepare_UNet_keys(write_PK_UNet)\n", + "# # ++++++++++++++++++++++++++++++++++++++\n", + "# # beyond UNet, for Whole model, all keys\n", + "# # \"None\" means defult value on function definition\n", + "# write_PK_Imagen=dict()\n", + "\n", + "# # used ones\n", + "# write_PK_Imagen['timesteps']=ModelKeys['diff_timesteps']\n", + "# write_PK_Imagen['dim']=ModelKeys['dim']\n", + "# write_PK_Imagen['pred_dim']=ModelKeys['pred_dim']\n", + "# write_PK_Imagen['loss_type']=ModelKeys['loss_type'] # 0 # MSE\n", + "# write_PK_Imagen['elucidated']=ModelKeys['elucidated'] # True\n", + "# write_PK_Imagen['padding_idx']=ModelKeys['padding_idx'] # 0 # need to check\n", + "# write_PK_Imagen['cond_dim']=ModelKeys['cond_dim'] # use default\n", + "# # can use default, 512; or like the below (check the code)\n", + "# write_PK_Imagen['text_embed_dim']=ModelKeys['text_embed_dim']-ModelKeys['embed_dim_position']\n", + "# # write_PK_Imagen['input_tokens']=None\n", + "# # write_PK_Imagen['sequence_embed']=None\n", + "# write_PK_Imagen['embed_dim_position']=ModelKeys['embed_dim_position']\n", + "# write_PK_Imagen['max_text_len']=ModelKeys['max_text_len']\n", + "# write_PK_Imagen['cond_images_channels']=ModelKeys['cond_images_channels']\n", + "# write_PK_Imagen['max_length']=ModelKeys['max_length']\n", + "# write_PK_Imagen['device']=ModelKeys['device']\n", + "\n", + "# # extend it to a full key\n", + "# ModelKeys['Imagen']=UtilityPack.prepare_ModelB_keys(write_PK_Imagen)\n", + "\n", + " elif CKeys['Problem_ID']==4:\n", + " pass\n", + "\n", + "# ModelKeys={}\n", + "# # storage\n", + "# ModelKeys['model_dir']=PKeys['prefix']+'1_model_SS/'\n", + "# # create the folder\n", + "# print(\"Creating the model dir...\")\n", + "# UtilityPack.create_path(ModelKeys['model_dir'])\n", + "# # secondary folders\n", + "# ModelKeys['model_dir_sample']=ModelKeys['model_dir']+'0_mid_sample/'\n", + "# UtilityPack.create_path(ModelKeys['model_dir_sample'])\n", + "# ModelKeys['model_dir_model']=ModelKeys['model_dir']+'1_store_model/'\n", + "# UtilityPack.create_path(ModelKeys['model_dir_model'])\n", + "\n", + "# # for UNet\n", + "# ModelKeys['dim']=768 # dim for UNet\n", + "# # for debug\n", + "# ModelKeys['dim']=256 # dim for UNet: GPU stat: 256:16093MiB;\n", + "# #\n", + "# ModelKeys['text_embed_dim']=512-128\n", + "# ModelKeys['embed_dim_position']=128\n", + "# # ! this is for UNet, not for Imagen\n", + "# ModelKeys['text_embed_dim']=ModelKeys['text_embed_dim']+ModelKeys['embed_dim_position']\n", + "# ModelKeys['cond_dim']=512\n", + "# # ModelKeys['embed_dim_position']=128\n", + "# # ModelKeys['text_embed_dim']=ModelKeys['cond_dim']-ModelKeys['embed_dim_position']\n", + "# # !!! Need to check this one = 1 or not\n", + "# ModelKeys['cond_images_channels']=0 # 1\n", + "# # !!! Need to check this one: should it be 8 or 64?\n", + "# ModelKeys['max_text_len']= DataKeys['max_text_len'] # DataKeys['max_AA_seq_len'] # 8 # this is about text condi\n", + "\n", + "# # for Imagen\n", + "# ModelKeys['pred_dim']=1 # for sequence, =1\n", + "# ModelKeys['diff_timesteps']=(96) # (96,)\n", + "# ModelKeys['loss_type']=0 # MSE\n", + "# ModelKeys['elucidated']=True #\n", + "# ModelKeys['padding_idx']=0\n", + "# ModelKeys['max_length']=DataKeys['max_AA_seq_len']\n", + "# ModelKeys['device']=device\n", + "# #\n", + "# # baskets for Model building\n", + "# ModelKeys['UNet']={}\n", + "# ModelKeys['Imagen']={}\n", + "# # ++++++++++++++++++++++++++++++++++++++\n", + "# # prepare the Unet Key\n", + "# write_PK_UNet=dict()\n", + "# # used ones\n", + "# write_PK_UNet['dim']=ModelKeys['dim']\n", + "# write_PK_UNet['text_embed_dim']=ModelKeys['text_embed_dim']\n", + "# write_PK_UNet['num_resnet_blocks']=1\n", + "# write_PK_UNet['cond_dim']=ModelKeys['cond_dim'] #this is where text embeddings are projected to...\n", + "# # write_PK_UNet['num_image_tokens']=None # using the default value\n", + "# # write_PK_UNet['num_time_tokens']=None # using the default\n", + "# # write_PK_UNet['learned_sinu_pos_emb_dim']=None\n", + "# # write_PK_UNet['out_dim']=None\n", + "# write_PK_UNet['dim_mults']=(1, 2, 4, 8)\n", + "\n", + "# write_PK_UNet['cond_images_channels']=ModelKeys['cond_images_channels']\n", + "# write_PK_UNet['channels']=ModelKeys['pred_dim']\n", + "# write_PK_UNet['channels_out']=ModelKeys['pred_dim']\n", + "\n", + "# write_PK_UNet['attn_dim_head']=64\n", + "# write_PK_UNet['attn_heads']=8\n", + "# write_PK_UNet['ff_mult']=2.\n", + "# write_PK_UNet['lowres_cond']=False # for cascading diffusion - https://cascaded-diffusion.github.io/\n", + "\n", + "\n", + "# write_PK_UNet['layer_attns']=(False, True, True, False)\n", + "# write_PK_UNet['layer_attns_depth']=1\n", + "# write_PK_UNet['layer_attns_add_text_cond']=True # whether to condition the self-attention blocks with the text embeddings, as described in Appendix D.3.1\n", + "# write_PK_UNet['attend_at_middle']=True # whether to have a layer of attention at the bottleneck (can turn off for higher resolution in cascading DDPM, before bringing in efficient attention)\n", + "# write_PK_UNet['layer_cross_attns']=(False, True, True, False)\n", + "# write_PK_UNet['use_linear_attn']=False\n", + "# write_PK_UNet['use_linear_cross_attn']=False\n", + "\n", + "# write_PK_UNet['cond_on_text'] = True\n", + "# # !!! Need to check this: 63, Imagen used a different one\n", + "# write_PK_UNet['max_text_len'] = DataKeys['max_text_len'] # DataKeys['max_AA_seq_len'] # ModelKeys['max_text_len']\n", + "# # write_PK_UNet['init_dim'] = None\n", + "# write_PK_UNet['resnet_groups'] = 8\n", + "# write_PK_UNet['init_conv_kernel_size'] =7 # kernel size of initial conv, if not using cross embed\n", + "# write_PK_UNet['init_cross_embed'] = False #TODO - fix ouput size calcs for conv1d\n", + "# write_PK_UNet['init_cross_embed_kernel_sizes'] = (3, 7, 15)\n", + "# write_PK_UNet['cross_embed_downsample'] = False\n", + "# write_PK_UNet['cross_embed_downsample_kernel_sizes'] = (2, 4)\n", + "\n", + "# write_PK_UNet['attn_pool_text'] = True\n", + "# write_PK_UNet['attn_pool_num_latents'] = 32 #32, #perceiver model latents\n", + "# write_PK_UNet['dropout'] = 0.\n", + "# write_PK_UNet['memory_efficient'] = False\n", + "# write_PK_UNet['init_conv_to_final_conv_residual'] = False\n", + "\n", + "# write_PK_UNet['use_global_context_attn'] = True\n", + "# write_PK_UNet['scale_skip_connection'] = True\n", + "# write_PK_UNet['final_resnet_block'] = True\n", + "# write_PK_UNet['final_conv_kernel_size'] = 3\n", + "\n", + "# write_PK_UNet['cosine_sim_attn'] = True\n", + "# write_PK_UNet['self_cond'] = False\n", + "# write_PK_UNet['combine_upsample_fmaps'] = True # combine feature maps from all upsample blocks, used in unet squared successfully\n", + "# write_PK_UNet['pixel_shuffle_upsample'] = False # may address checkboard artifacts\n", + "# # write_PK_UNet['beginning_and_final_conv_present']=None # use default\n", + "# #\n", + "# ModelKeys['UNet']=UtilityPack.prepare_UNet_keys(write_PK_UNet)\n", + "# # ++++++++++++++++++++++++++++++++++++++\n", + "# # beyond UNet, for Whole model, all keys\n", + "# # \"None\" means defult value on function definition\n", + "# write_PK_Imagen=dict()\n", + "\n", + "# # used ones\n", + "# write_PK_Imagen['timesteps']=ModelKeys['diff_timesteps']\n", + "# write_PK_Imagen['dim']=ModelKeys['dim']\n", + "# write_PK_Imagen['pred_dim']=ModelKeys['pred_dim']\n", + "# write_PK_Imagen['loss_type']=ModelKeys['loss_type'] # 0 # MSE\n", + "# write_PK_Imagen['elucidated']=ModelKeys['elucidated'] # True\n", + "# write_PK_Imagen['padding_idx']=ModelKeys['padding_idx'] # 0 # need to check\n", + "# write_PK_Imagen['cond_dim']=ModelKeys['cond_dim'] # use default\n", + "# # can use default, 512; or like the below (check the code)\n", + "# write_PK_Imagen['text_embed_dim']=ModelKeys['text_embed_dim']-ModelKeys['embed_dim_position']\n", + "# # write_PK_Imagen['input_tokens']=None\n", + "# # write_PK_Imagen['sequence_embed']=None\n", + "# write_PK_Imagen['embed_dim_position']=ModelKeys['embed_dim_position']\n", + "# write_PK_Imagen['max_text_len']=ModelKeys['max_text_len']\n", + "# write_PK_Imagen['cond_images_channels']=ModelKeys['cond_images_channels']\n", + "# write_PK_Imagen['max_length']=ModelKeys['max_length']\n", + "# write_PK_Imagen['device']=ModelKeys['device']\n", + "\n", + "# # extend it to a full key\n", + "# ModelKeys['Imagen']=UtilityPack.prepare_ModelB_keys(write_PK_Imagen)\n", + "\n", + " elif CKeys['Problem_ID']==5:\n", + " pass\n", + "\n", + "# # this is 1st run....\n", + "# # +++++++++++++++++++++++++++++++++++++\n", + "# # SecStr as input seq\n", + "# ModelKeys={}\n", + "# # storage\n", + "# ModelKeys['model_dir']=PKeys['prefix']+'1_model_SS/'\n", + "# # create the folder\n", + "# print(\"Creating the model dir...\")\n", + "# UtilityPack.create_path(ModelKeys['model_dir'])\n", + "# # secondary folders\n", + "# ModelKeys['model_dir_sample']=ModelKeys['model_dir']+'0_mid_sample/'\n", + "# UtilityPack.create_path(ModelKeys['model_dir_sample'])\n", + "# ModelKeys['model_dir_model']=ModelKeys['model_dir']+'1_store_model/'\n", + "# UtilityPack.create_path(ModelKeys['model_dir_model'])\n", + "\n", + "# # for UNet\n", + "# ModelKeys['dim']=256 # dim for UNet\n", + "# ModelKeys['text_embed_dim'] = 512\n", + "# ModelKeys['embed_dim_position']=32\n", + "# ModelKeys['text_embed_dim']=ModelKeys['text_embed_dim']+ModelKeys['embed_dim_position']\n", + "# ModelKeys['cond_dim'] = 512\n", + "# ModelKeys['cond_images_channels']=DataKeys['image_channels'] # 1280 # for embedding dim # 1\n", + "# ModelKeys['max_text_len']=DataKeys['max_AA_seq_len'] # this is about text condi\n", + "# # + for embedding\n", + "# ModelKeys['image_channels']=DataKeys['image_channels'] # 1280\n", + "# # for Imagen\n", + "# ModelKeys['pred_dim']= ModelKeys['image_channels'] # 1 # for sequence, =1\n", + "# ModelKeys['diff_timesteps']=(96,)\n", + "# ModelKeys['loss_type']=0 # MSE\n", + "# ModelKeys['elucidated']=True #\n", + "# ModelKeys['padding_idx']=0\n", + "# ModelKeys['max_length']=DataKeys['max_AA_seq_len'] # max seq len\n", + "# ModelKeys['device']=device\n", + "# #\n", + "# # buckets for Model building\n", + "# ModelKeys['UNet']={}\n", + "# ModelKeys['Imagen']={}\n", + "# # ++++++++++++++++++++++++++++++++++++++++++++++++++\n", + "# write_PK_UNet=dict()\n", + "# write_PK_UNet['dim']=ModelKeys['dim'] # 256\n", + "# write_PK_UNet['text_embed_dim']=ModelKeys['text_embed_dim'] # 512+32\n", + "# write_PK_UNet['num_resnet_blocks']=1\n", + "# write_PK_UNet['cond_dim']=ModelKeys['cond_dim'] #this is where text embeddings are projected to...\n", + "# # write_PK_UNet['num_image_tokens']=None # using the default value\n", + "# # write_PK_UNet['num_time_tokens']=None # using the default\n", + "# # write_PK_UNet['learned_sinu_pos_emb_dim']=None\n", + "# # write_PK_UNet['out_dim']=None\n", + "# write_PK_UNet['dim_mults']=(1, 2, 4, 8)\n", + "\n", + "# write_PK_UNet['cond_images_channels']=ModelKeys['cond_images_channels']\n", + "# write_PK_UNet['channels']=ModelKeys['image_channels'] # 1\n", + "# write_PK_UNet['channels_out']=ModelKeys['image_channels'] # 1\n", + "\n", + "# write_PK_UNet['attn_dim_head']=64\n", + "# write_PK_UNet['attn_heads']=8\n", + "# write_PK_UNet['ff_mult']=2.\n", + "# write_PK_UNet['lowres_cond']=False # for cascading diffusion - https://cascaded-diffusion.github.io/\n", + "\n", + "# write_PK_UNet['layer_attns']=(False, True, True, False)\n", + "# write_PK_UNet['layer_attns_depth']=1\n", + "# write_PK_UNet['layer_attns_add_text_cond']=True # whether to condition the self-attention blocks with the text embeddings, as described in Appendix D.3.1\n", + "# write_PK_UNet['attend_at_middle']=True # whether to have a layer of attention at the bottleneck (can turn off for higher resolution in cascading DDPM, before bringing in efficient attention)\n", + "# write_PK_UNet['layer_cross_attns']=(False, True, True, False)\n", + "# write_PK_UNet['use_linear_attn']=False\n", + "# write_PK_UNet['use_linear_cross_attn']=False\n", + "\n", + "# write_PK_UNet['cond_on_text']=True\n", + "# write_PK_UNet['max_text_len']=ModelKeys['max_text_len'] # need to check this one\n", + "# # ModelKeys['UNet']['init_dim']=None\n", + "# write_PK_UNet['resnet_groups']=8\n", + "# write_PK_UNet['init_conv_kernel_size']=7 # kernel size of initial conv, if not using cross embed\n", + "# write_PK_UNet['init_cross_embed']=False #TODO - fix ouput size calcs for conv1d\n", + "# write_PK_UNet['init_cross_embed_kernel_sizes']=(3, 7, 15)\n", + "# write_PK_UNet['cross_embed_downsample']=False\n", + "# write_PK_UNet['cross_embed_downsample_kernel_sizes']=(2, 4)\n", + "\n", + "# write_PK_UNet['attn_pool_text']=True\n", + "# write_PK_UNet['attn_pool_num_latents']=32 #perceiver model latents\n", + "# write_PK_UNet['dropout']=0.\n", + "# write_PK_UNet['memory_efficient']=False\n", + "# write_PK_UNet['init_conv_to_final_conv_residual']=False\n", + "\n", + "# write_PK_UNet['use_global_context_attn']=True\n", + "# write_PK_UNet['scale_skip_connection']=True\n", + "# write_PK_UNet['final_resnet_block']=True\n", + "# write_PK_UNet['final_conv_kernel_size']=3\n", + "\n", + "# write_PK_UNet['cosine_sim_attn']=True\n", + "# write_PK_UNet['self_cond']=False\n", + "# write_PK_UNet['combine_upsample_fmaps']=True # combine feature maps from all upsample blocks, used in unet squared successfully\n", + "# write_PK_UNet['pixel_shuffle_upsample']=False # may address checkboard artifacts\n", + "# # write_PK_UNet['beginning_and_final_conv_present']=None # use default\n", + "# ModelKeys['UNet']=UtilityPack.prepare_UNet_keys(write_PK_UNet)\n", + "# # +++++++++++++++++++++++++++++++++++++++++++++++++++++\n", + "# # beyond UNet, for Whole model, all keys\n", + "# # \"None\" means defult value on function definition\n", + "# write_PK_Imagen=dict()\n", + "\n", + "# write_PK_Imagen['timesteps']=ModelKeys['diff_timesteps']\n", + "# write_PK_Imagen['dim']=ModelKeys['dim']\n", + "# write_PK_Imagen['pred_dim']=ModelKeys['pred_dim']\n", + "# write_PK_Imagen['loss_type']=ModelKeys['loss_type'] # 0 # MSE\n", + "# write_PK_Imagen['elucidated']=ModelKeys['elucidated'] # True\n", + "# write_PK_Imagen['padding_idx']=ModelKeys['padding_idx'] # 0 # need to check\n", + "# # write_PK_Imagen['cond_dim']=None # use default\n", + "# # write_PK_Imagen['text_embed_dim']=None\n", + "# # write_PK_Imagen['input_tokens']=None\n", + "# # write_PK_Imagen['sequence_embed']=None\n", + "# # write_PK_Imagen['embed_dim_position']=None\n", + "# write_PK_Imagen['max_text_len']=ModelKeys['max_text_len']\n", + "# write_PK_Imagen['cond_images_channels']=ModelKeys['pred_dim']\n", + "# write_PK_Imagen['max_length']=ModelKeys['max_length']\n", + "# write_PK_Imagen['device']=ModelKeys['device']\n", + "\n", + "# # extend it to a full key\n", + "# ModelKeys['Imagen']=UtilityPack.prepare_ModelB_keys(write_PK_Imagen)\n", + "\n", + " elif CKeys['Problem_ID']==6:\n", + " # =====================================================\n", + " # ForcePath --> AA sequence\n", + " # =====================================================\n", + " #\n", + " # this is 1st run....\n", + " # +++++++++++++++++++++++++++++++++++++\n", + " # ForcPath as input seq\n", + " ModelKeys={}\n", + " # storage\n", + " ModelKeys['model_dir']=PKeys['prefix']+'1_model_SS/'\n", + " # create the folder\n", + " print(\"Creating the model dir...\")\n", + " UtilityPack.create_path(ModelKeys['model_dir'])\n", + " # secondary folders\n", + " ModelKeys['model_dir_sample']=ModelKeys['model_dir']+'0_mid_sample/'\n", + " UtilityPack.create_path(ModelKeys['model_dir_sample'])\n", + " ModelKeys['model_dir_model']=ModelKeys['model_dir']+'1_store_model/'\n", + " UtilityPack.create_path(ModelKeys['model_dir_model'])\n", + "\n", + " # for UNet\n", + " ModelKeys['dim']=256 # dim for UNet\n", + " ModelKeys['text_embed_dim'] = 512\n", + " ModelKeys['embed_dim_position']=32\n", + " ModelKeys['text_embed_dim']=ModelKeys['text_embed_dim']+ModelKeys['embed_dim_position']\n", + " ModelKeys['cond_dim'] = 512\n", + " ModelKeys['cond_images_channels']=DataKeys['image_channels'] # 1\n", + " ModelKeys['max_text_len']=DataKeys['max_AA_seq_len'] # this is about text condi\n", + " # for Imagen\n", + " ModelKeys['pred_dim']=DataKeys['image_channels'] # 1 # for sequence, =1\n", + " ModelKeys['diff_timesteps']=(96,)\n", + " ModelKeys['loss_type']=0 # MSE\n", + " ModelKeys['elucidated']=True #\n", + " ModelKeys['padding_idx']=0\n", + " ModelKeys['max_length']=DataKeys['max_AA_seq_len'] # max seq len\n", + " ModelKeys['device']=device\n", + " #\n", + " # buckets for Model building\n", + " ModelKeys['UNet']={}\n", + " ModelKeys['Imagen']={}\n", + " # ++++++++++++++++++++++++++++++++++++++++++++++++++\n", + " write_PK_UNet=dict()\n", + " write_PK_UNet['dim']=ModelKeys['dim'] # 256\n", + " write_PK_UNet['text_embed_dim']=ModelKeys['text_embed_dim'] # 512+32\n", + " write_PK_UNet['num_resnet_blocks']=1\n", + " write_PK_UNet['cond_dim']=ModelKeys['cond_dim'] #this is where text embeddings are projected to...\n", + " # write_PK_UNet['num_image_tokens']=None # using the default value\n", + " # write_PK_UNet['num_time_tokens']=None # using the default\n", + " # write_PK_UNet['learned_sinu_pos_emb_dim']=None\n", + " # write_PK_UNet['out_dim']=None\n", + " write_PK_UNet['dim_mults']=(1, 2, 4, 8)\n", + "\n", + " write_PK_UNet['cond_images_channels']=ModelKeys['cond_images_channels']\n", + " write_PK_UNet['channels']=DataKeys['image_channels'] # 1\n", + " write_PK_UNet['channels_out']=DataKeys['image_channels'] # 1\n", + "\n", + " write_PK_UNet['attn_dim_head']=64\n", + " write_PK_UNet['attn_heads']=8\n", + " write_PK_UNet['ff_mult']=2.\n", + " write_PK_UNet['lowres_cond']=False # for cascading diffusion - https://cascaded-diffusion.github.io/\n", + "\n", + " write_PK_UNet['layer_attns']=(False, True, True, False)\n", + " write_PK_UNet['layer_attns_depth']=1\n", + " write_PK_UNet['layer_attns_add_text_cond']=True # whether to condition the self-attention blocks with the text embeddings, as described in Appendix D.3.1\n", + " write_PK_UNet['attend_at_middle']=True # whether to have a layer of attention at the bottleneck (can turn off for higher resolution in cascading DDPM, before bringing in efficient attention)\n", + " write_PK_UNet['layer_cross_attns']=(False, True, True, False)\n", + " write_PK_UNet['use_linear_attn']=False\n", + " write_PK_UNet['use_linear_cross_attn']=False\n", + "\n", + " write_PK_UNet['cond_on_text']=True\n", + " write_PK_UNet['max_text_len']=ModelKeys['max_text_len'] # need to check this one\n", + " # ModelKeys['UNet']['init_dim']=None\n", + " write_PK_UNet['resnet_groups']=8\n", + " write_PK_UNet['init_conv_kernel_size']=7 # kernel size of initial conv, if not using cross embed\n", + " write_PK_UNet['init_cross_embed']=False #TODO - fix ouput size calcs for conv1d\n", + " write_PK_UNet['init_cross_embed_kernel_sizes']=(3, 7, 15)\n", + " write_PK_UNet['cross_embed_downsample']=False\n", + " write_PK_UNet['cross_embed_downsample_kernel_sizes']=(2, 4)\n", + "\n", + " write_PK_UNet['attn_pool_text']=True\n", + " write_PK_UNet['attn_pool_num_latents']=32 #perceiver model latents\n", + " write_PK_UNet['dropout']=0.\n", + " write_PK_UNet['memory_efficient']=False\n", + " write_PK_UNet['init_conv_to_final_conv_residual']=False\n", + "\n", + " write_PK_UNet['use_global_context_attn']=True\n", + " write_PK_UNet['scale_skip_connection']=True\n", + " write_PK_UNet['final_resnet_block']=True\n", + " write_PK_UNet['final_conv_kernel_size']=3\n", + "\n", + " write_PK_UNet['cosine_sim_attn']=True\n", + " write_PK_UNet['self_cond']=False\n", + " write_PK_UNet['combine_upsample_fmaps']=True # combine feature maps from all upsample blocks, used in unet squared successfully\n", + " write_PK_UNet['pixel_shuffle_upsample']=False # may address checkboard artifacts\n", + " # write_PK_UNet['beginning_and_final_conv_present']=None # use default\n", + " ModelKeys['UNet']=UtilityPack.prepare_UNet_keys(write_PK_UNet)\n", + " # +++++++++++++++++++++++++++++++++++++++++++++++++++++\n", + " # beyond UNet, for Whole model, all keys\n", + " # \"None\" means defult value on function definition\n", + " write_PK_Imagen=dict()\n", + "\n", + " write_PK_Imagen['timesteps']=ModelKeys['diff_timesteps']\n", + " write_PK_Imagen['dim']=ModelKeys['dim']\n", + " write_PK_Imagen['pred_dim']=ModelKeys['pred_dim']\n", + " write_PK_Imagen['loss_type']=ModelKeys['loss_type'] # 0 # MSE\n", + " write_PK_Imagen['elucidated']=ModelKeys['elucidated'] # True\n", + " write_PK_Imagen['padding_idx']=ModelKeys['padding_idx'] # 0 # need to check\n", + " # write_PK_Imagen['cond_dim']=None # use default\n", + " # write_PK_Imagen['text_embed_dim']=None\n", + " # write_PK_Imagen['input_tokens']=None\n", + " # write_PK_Imagen['sequence_embed']=None\n", + " # write_PK_Imagen['embed_dim_position']=None\n", + " write_PK_Imagen['max_text_len']=ModelKeys['max_text_len']\n", + " write_PK_Imagen['cond_images_channels']=ModelKeys['cond_images_channels']\n", + " write_PK_Imagen['max_length']=ModelKeys['max_length']\n", + " write_PK_Imagen['device']=ModelKeys['device']\n", + "\n", + " # extend it to a full key\n", + " ModelKeys['Imagen']=UtilityPack.prepare_ModelB_keys(write_PK_Imagen)\n", + " # to be defined\n", + "\n", + " elif CKeys['Problem_ID']==7:\n", + " pass\n", + "# # ================================================================\n", + "# # SecStr text summary --> AA seq pLM embedding\n", + "# # ================================================================\n", + "# ModelKeys={}\n", + "# # storage\n", + "# ModelKeys['model_dir']=PKeys['prefix']+'1_model_SS/'\n", + "# # create the folder\n", + "# print(\"Creating the model dir...\")\n", + "# UtilityPack.create_path(ModelKeys['model_dir'])\n", + "# # secondary folders\n", + "# ModelKeys['model_dir_sample']=ModelKeys['model_dir']+'0_mid_sample/'\n", + "# UtilityPack.create_path(ModelKeys['model_dir_sample'])\n", + "# ModelKeys['model_dir_model']=ModelKeys['model_dir']+'1_store_model/'\n", + "# UtilityPack.create_path(ModelKeys['model_dir_model'])\n", + "\n", + "# # for UNet\n", + "# ModelKeys['dim']=768 # dim for UNet\n", + "# # for debug\n", + "# ModelKeys['dim']=256 # dim for UNet: GPU stat: 256:16093MiB;\n", + "# #\n", + "# ModelKeys['text_embed_dim']=512-128\n", + "# ModelKeys['embed_dim_position']=128\n", + "# # ! this is for UNet, not for Imagen\n", + "# ModelKeys['text_embed_dim']=ModelKeys['text_embed_dim']+ModelKeys['embed_dim_position']\n", + "# ModelKeys['cond_dim']=512\n", + "# # ModelKeys['embed_dim_position']=128\n", + "# # ModelKeys['text_embed_dim']=ModelKeys['cond_dim']-ModelKeys['embed_dim_position']\n", + "# # !!! Need to check this one = 1 or not\n", + "# # $: UNet use this key to decide whether cond_img is provided or not (0)\n", + "# ModelKeys['cond_images_channels']= 0 # indicate NO cond_img # 0 # DataKeys['image_channels']\n", + "# # !!! Need to check this one: should it be 8 or 64?\n", + "# ModelKeys['max_text_len']= DataKeys['max_text_len'] # DataKeys['max_AA_seq_len'] # 8 # this is about text condi\n", + "\n", + "# # for Imagen\n", + "# ModelKeys['pred_dim']=DataKeys['image_channels'] # 1 # for sequence, =1\n", + "# ModelKeys['diff_timesteps']=(96) # (96,)\n", + "# ModelKeys['loss_type']=0 # MSE\n", + "# ModelKeys['elucidated']=True #\n", + "# ModelKeys['padding_idx']=0\n", + "# ModelKeys['max_length']=DataKeys['max_AA_seq_len']\n", + "# ModelKeys['device']=device\n", + "# #\n", + "# # baskets for Model building\n", + "# ModelKeys['UNet']={}\n", + "# ModelKeys['Imagen']={}\n", + "# # ++++++++++++++++++++++++++++++++++++++\n", + "# # prepare the Unet Key\n", + "# write_PK_UNet=dict()\n", + "# # used ones\n", + "# write_PK_UNet['dim']=ModelKeys['dim']\n", + "# write_PK_UNet['text_embed_dim']=ModelKeys['text_embed_dim']\n", + "# write_PK_UNet['num_resnet_blocks']=1\n", + "# write_PK_UNet['cond_dim']=ModelKeys['cond_dim'] #this is where text embeddings are projected to...\n", + "# # write_PK_UNet['num_image_tokens']=None # using the default value\n", + "# # write_PK_UNet['num_time_tokens']=None # using the default\n", + "# # write_PK_UNet['learned_sinu_pos_emb_dim']=None\n", + "# # write_PK_UNet['out_dim']=None\n", + "# write_PK_UNet['dim_mults']=(1, 2, 4, 8)\n", + "\n", + "# write_PK_UNet['cond_images_channels']=ModelKeys['cond_images_channels']\n", + "# write_PK_UNet['channels']=DataKeys['image_channels'] # ModelKeys['pred_dim']\n", + "# write_PK_UNet['channels_out']=DataKeys['image_channels'] # ModelKeys['pred_dim']\n", + "\n", + "# write_PK_UNet['attn_dim_head']=64\n", + "# write_PK_UNet['attn_heads']=8\n", + "# write_PK_UNet['ff_mult']=2.\n", + "# write_PK_UNet['lowres_cond']=False # for cascading diffusion - https://cascaded-diffusion.github.io/\n", + "\n", + "\n", + "# write_PK_UNet['layer_attns']=(False, True, True, False)\n", + "# write_PK_UNet['layer_attns_depth']=1\n", + "# write_PK_UNet['layer_attns_add_text_cond']=True # whether to condition the self-attention blocks with the text embeddings, as described in Appendix D.3.1\n", + "# write_PK_UNet['attend_at_middle']=True # whether to have a layer of attention at the bottleneck (can turn off for higher resolution in cascading DDPM, before bringing in efficient attention)\n", + "# write_PK_UNet['layer_cross_attns']=(False, True, True, False)\n", + "# write_PK_UNet['use_linear_attn']=False\n", + "# write_PK_UNet['use_linear_cross_attn']=False\n", + "\n", + "# write_PK_UNet['cond_on_text'] = True\n", + "# # !!! Need to check this: 63, Imagen used a different one\n", + "# # !!! here try the new one which seems to be correct\n", + "# write_PK_UNet['max_text_len'] = ModelKeys['max_text_len'] # DataKeys['max_AA_seq_len'] # ModelKeys['max_text_len']\n", + "# # write_PK_UNet['init_dim'] = None\n", + "# write_PK_UNet['resnet_groups'] = 8\n", + "# write_PK_UNet['init_conv_kernel_size'] =7 # kernel size of initial conv, if not using cross embed\n", + "# write_PK_UNet['init_cross_embed'] = False #TODO - fix ouput size calcs for conv1d\n", + "# write_PK_UNet['init_cross_embed_kernel_sizes'] = (3, 7, 15)\n", + "# write_PK_UNet['cross_embed_downsample'] = False\n", + "# write_PK_UNet['cross_embed_downsample_kernel_sizes'] = (2, 4)\n", + "\n", + "# write_PK_UNet['attn_pool_text'] = True\n", + "# write_PK_UNet['attn_pool_num_latents'] = 32 #32, #perceiver model latents\n", + "# write_PK_UNet['dropout'] = 0.\n", + "# write_PK_UNet['memory_efficient'] = False\n", + "# write_PK_UNet['init_conv_to_final_conv_residual'] = False\n", + "\n", + "# write_PK_UNet['use_global_context_attn'] = True\n", + "# write_PK_UNet['scale_skip_connection'] = True\n", + "# write_PK_UNet['final_resnet_block'] = True\n", + "# write_PK_UNet['final_conv_kernel_size'] = 3\n", + "\n", + "# write_PK_UNet['cosine_sim_attn'] = True\n", + "# write_PK_UNet['self_cond'] = False\n", + "# write_PK_UNet['combine_upsample_fmaps'] = True # combine feature maps from all upsample blocks, used in unet squared successfully\n", + "# write_PK_UNet['pixel_shuffle_upsample'] = False # may address checkboard artifacts\n", + "# # write_PK_UNet['beginning_and_final_conv_present']=None # use default\n", + "# #\n", + "# ModelKeys['UNet']=UtilityPack.prepare_UNet_keys(write_PK_UNet)\n", + "# # ++++++++++++++++++++++++++++++++++++++\n", + "# # beyond UNet, for Whole model, all keys\n", + "# # \"None\" means defult value on function definition\n", + "# write_PK_Imagen=dict()\n", + "\n", + "# # used ones\n", + "# write_PK_Imagen['timesteps']=ModelKeys['diff_timesteps']\n", + "# write_PK_Imagen['dim']=ModelKeys['dim']\n", + "# write_PK_Imagen['pred_dim']=ModelKeys['pred_dim']\n", + "# write_PK_Imagen['loss_type']=ModelKeys['loss_type'] # 0 # MSE\n", + "# write_PK_Imagen['elucidated']=ModelKeys['elucidated'] # True\n", + "# write_PK_Imagen['padding_idx']=ModelKeys['padding_idx'] # 0 # need to check\n", + "# write_PK_Imagen['cond_dim']=ModelKeys['cond_dim'] # use default\n", + "# # can use default, 512; or like the below (check the code)\n", + "# write_PK_Imagen['text_embed_dim']=ModelKeys['text_embed_dim']-ModelKeys['embed_dim_position']\n", + "# # write_PK_Imagen['input_tokens']=None\n", + "# # write_PK_Imagen['sequence_embed']=None\n", + "# write_PK_Imagen['embed_dim_position']=ModelKeys['embed_dim_position']\n", + "# write_PK_Imagen['max_text_len']=ModelKeys['max_text_len']\n", + "# write_PK_Imagen['cond_images_channels']=ModelKeys['cond_images_channels']\n", + "# write_PK_Imagen['max_length']=ModelKeys['max_length']\n", + "# write_PK_Imagen['device']=ModelKeys['device']\n", + "\n", + "# # extend it to a full key\n", + "# ModelKeys['Imagen']=UtilityPack.prepare_ModelB_keys(write_PK_Imagen)\n", + "\n", + " elif CKeys['Problem_ID']==8:\n", + " # ================================================================\n", + " # FmaxEne text summary --> AA seq pLM embedding\n", + " # ================================================================\n", + " ModelKeys={}\n", + " # storage\n", + " ModelKeys['model_dir']=PKeys['prefix']+'1_model_SS/'\n", + " # create the folder\n", + " print(\"Creating the model dir...\")\n", + " UtilityPack.create_path(ModelKeys['model_dir'])\n", + " # secondary folders\n", + " ModelKeys['model_dir_sample']=ModelKeys['model_dir']+'0_mid_sample/'\n", + " UtilityPack.create_path(ModelKeys['model_dir_sample'])\n", + " ModelKeys['model_dir_model']=ModelKeys['model_dir']+'1_store_model/'\n", + " UtilityPack.create_path(ModelKeys['model_dir_model'])\n", + "\n", + " # for UNet\n", + " ModelKeys['dim']=768 # dim for UNet\n", + " # for debug\n", + " ModelKeys['dim']=256 # dim for UNet: GPU stat: 256:16093MiB;\n", + " #\n", + " ModelKeys['text_embed_dim']=512-128\n", + " ModelKeys['embed_dim_position']=128\n", + " # ! this is for UNet, not for Imagen\n", + " ModelKeys['text_embed_dim']=ModelKeys['text_embed_dim']+ModelKeys['embed_dim_position']\n", + " ModelKeys['cond_dim']=512\n", + " # ModelKeys['embed_dim_position']=128\n", + " # ModelKeys['text_embed_dim']=ModelKeys['cond_dim']-ModelKeys['embed_dim_position']\n", + " # !!! Need to check this one = 1 or not\n", + " # $: UNet use this key to decide whether cond_img is provided or not (0)\n", + " ModelKeys['cond_images_channels']=0 # indicate no cond_img is used # 1\n", + " # !!! Need to check this one: should it be 8 or 64?\n", + " ModelKeys['max_text_len']= DataKeys['max_text_len'] # DataKeys['max_AA_seq_len'] # 8 # this is about text condi\n", + "\n", + " # for Imagen\n", + " ModelKeys['pred_dim']=DataKeys['image_channels'] # 1 # for sequence, =1\n", + " ModelKeys['diff_timesteps']=(96) # (96,)\n", + " ModelKeys['loss_type']=0 # MSE\n", + " ModelKeys['elucidated']=True #\n", + " ModelKeys['padding_idx']=0\n", + " ModelKeys['max_length']=DataKeys['max_AA_seq_len']\n", + " ModelKeys['device']=device\n", + " #\n", + " # baskets for Model building\n", + " ModelKeys['UNet']={}\n", + " ModelKeys['Imagen']={}\n", + " # ++++++++++++++++++++++++++++++++++++++\n", + " # prepare the Unet Key\n", + " write_PK_UNet=dict()\n", + " # used ones\n", + " write_PK_UNet['dim']=ModelKeys['dim']\n", + " write_PK_UNet['text_embed_dim']=ModelKeys['text_embed_dim']\n", + " write_PK_UNet['num_resnet_blocks']=1\n", + " write_PK_UNet['cond_dim']=ModelKeys['cond_dim'] #this is where text embeddings are projected to...\n", + " # write_PK_UNet['num_image_tokens']=None # using the default value\n", + " # write_PK_UNet['num_time_tokens']=None # using the default\n", + " # write_PK_UNet['learned_sinu_pos_emb_dim']=None\n", + " # write_PK_UNet['out_dim']=None\n", + " write_PK_UNet['dim_mults']=(1, 2, 4, 8)\n", + "\n", + " write_PK_UNet['cond_images_channels']=ModelKeys['cond_images_channels']\n", + " write_PK_UNet['channels']=DataKeys['image_channels'] # ModelKeys['pred_dim']\n", + " write_PK_UNet['channels_out']=DataKeys['image_channels'] # ModelKeys['pred_dim']\n", + "\n", + " write_PK_UNet['attn_dim_head']=64\n", + " write_PK_UNet['attn_heads']=8\n", + " write_PK_UNet['ff_mult']=2.\n", + " write_PK_UNet['lowres_cond']=False # for cascading diffusion - https://cascaded-diffusion.github.io/\n", + "\n", + "\n", + " write_PK_UNet['layer_attns']=(False, True, True, False)\n", + " write_PK_UNet['layer_attns_depth']=1\n", + " write_PK_UNet['layer_attns_add_text_cond']=True # whether to condition the self-attention blocks with the text embeddings, as described in Appendix D.3.1\n", + " write_PK_UNet['attend_at_middle']=True # whether to have a layer of attention at the bottleneck (can turn off for higher resolution in cascading DDPM, before bringing in efficient attention)\n", + " write_PK_UNet['layer_cross_attns']=(False, True, True, False)\n", + " write_PK_UNet['use_linear_attn']=False\n", + " write_PK_UNet['use_linear_cross_attn']=False\n", + "\n", + " write_PK_UNet['cond_on_text'] = True\n", + " # !!! Need to check this: 63, Imagen used a different one\n", + " write_PK_UNet['max_text_len'] = DataKeys['max_text_len'] # DataKeys['max_AA_seq_len'] # ModelKeys['max_text_len']\n", + " # write_PK_UNet['init_dim'] = None\n", + " write_PK_UNet['resnet_groups'] = 8\n", + " write_PK_UNet['init_conv_kernel_size'] =7 # kernel size of initial conv, if not using cross embed\n", + " write_PK_UNet['init_cross_embed'] = False #TODO - fix ouput size calcs for conv1d\n", + " write_PK_UNet['init_cross_embed_kernel_sizes'] = (3, 7, 15)\n", + " write_PK_UNet['cross_embed_downsample'] = False\n", + " write_PK_UNet['cross_embed_downsample_kernel_sizes'] = (2, 4)\n", + "\n", + " write_PK_UNet['attn_pool_text'] = True\n", + " write_PK_UNet['attn_pool_num_latents'] = 32 #32, #perceiver model latents\n", + " write_PK_UNet['dropout'] = 0.\n", + " write_PK_UNet['memory_efficient'] = False\n", + " write_PK_UNet['init_conv_to_final_conv_residual'] = False\n", + "\n", + " write_PK_UNet['use_global_context_attn'] = True\n", + " write_PK_UNet['scale_skip_connection'] = True\n", + " write_PK_UNet['final_resnet_block'] = True\n", + " write_PK_UNet['final_conv_kernel_size'] = 3\n", + "\n", + " write_PK_UNet['cosine_sim_attn'] = True\n", + " write_PK_UNet['self_cond'] = False\n", + " write_PK_UNet['combine_upsample_fmaps'] = True # combine feature maps from all upsample blocks, used in unet squared successfully\n", + " write_PK_UNet['pixel_shuffle_upsample'] = False # may address checkboard artifacts\n", + " # write_PK_UNet['beginning_and_final_conv_present']=None # use default\n", + " #\n", + " ModelKeys['UNet']=UtilityPack.prepare_UNet_keys(write_PK_UNet)\n", + " # ++++++++++++++++++++++++++++++++++++++\n", + " # beyond UNet, for Whole model, all keys\n", + " # \"None\" means defult value on function definition\n", + " write_PK_Imagen=dict()\n", + "\n", + " # used ones\n", + " write_PK_Imagen['timesteps']=ModelKeys['diff_timesteps']\n", + " write_PK_Imagen['dim']=ModelKeys['dim']\n", + " write_PK_Imagen['pred_dim']=ModelKeys['pred_dim']\n", + " write_PK_Imagen['loss_type']=ModelKeys['loss_type'] # 0 # MSE\n", + " write_PK_Imagen['elucidated']=ModelKeys['elucidated'] # True\n", + " write_PK_Imagen['padding_idx']=ModelKeys['padding_idx'] # 0 # need to check\n", + " write_PK_Imagen['cond_dim']=ModelKeys['cond_dim'] # use default\n", + " # can use default, 512; or like the below (check the code)\n", + " write_PK_Imagen['text_embed_dim']=ModelKeys['text_embed_dim']-ModelKeys['embed_dim_position']\n", + " # write_PK_Imagen['input_tokens']=None\n", + " # write_PK_Imagen['sequence_embed']=None\n", + " write_PK_Imagen['embed_dim_position']=ModelKeys['embed_dim_position']\n", + " write_PK_Imagen['max_text_len']=ModelKeys['max_text_len']\n", + " write_PK_Imagen['cond_images_channels']=ModelKeys['cond_images_channels']\n", + " write_PK_Imagen['max_length']=ModelKeys['max_length']\n", + " write_PK_Imagen['device']=ModelKeys['device']\n", + "\n", + " # extend it to a full key\n", + " ModelKeys['Imagen']=UtilityPack.prepare_ModelB_keys(write_PK_Imagen)\n", + "\n", + " elif CKeys['Problem_ID']==11:\n", + " # =====================================================\n", + " # ForcePath --> AA sequence\n", + " # =====================================================\n", + " #\n", + " # this is 1st run....\n", + " # +++++++++++++++++++++++++++++++++++++\n", + " # ForcPath as input seq\n", + " ModelKeys={}\n", + " # storage\n", + " ModelKeys['model_dir']=PKeys['prefix']+'1_model_SS/'\n", + " # create the folder\n", + " print(\"Creating the model dir...\")\n", + " UtilityPack.create_path(ModelKeys['model_dir'])\n", + " # secondary folders\n", + " ModelKeys['model_dir_sample']=ModelKeys['model_dir']+'0_mid_sample/'\n", + " UtilityPack.create_path(ModelKeys['model_dir_sample'])\n", + " ModelKeys['model_dir_model']=ModelKeys['model_dir']+'1_store_model/'\n", + " UtilityPack.create_path(ModelKeys['model_dir_model'])\n", + "\n", + " # for UNet\n", + " ModelKeys['dim']=256 # dim for UNet\n", + " ModelKeys['text_embed_dim'] = 512\n", + " ModelKeys['embed_dim_position']=32\n", + " ModelKeys['text_embed_dim']=ModelKeys['text_embed_dim']+ModelKeys['embed_dim_position']\n", + " ModelKeys['cond_dim'] = 512\n", + " ModelKeys['cond_images_channels']=DataKeys['image_channels'] # 1\n", + " ModelKeys['max_text_len']=DataKeys['max_AA_seq_len'] # this is about text condi\n", + " # for Imagen\n", + " ModelKeys['pred_dim']=DataKeys['image_channels'] # 1 # for sequence, =1\n", + " ModelKeys['diff_timesteps']=(96,)\n", + " ModelKeys['loss_type']=0 # MSE\n", + " ModelKeys['elucidated']=True #\n", + " ModelKeys['padding_idx']=0\n", + " ModelKeys['max_length']=DataKeys['max_AA_seq_len'] # max seq len\n", + " ModelKeys['device']=device\n", + " #\n", + " # buckets for Model building\n", + " ModelKeys['UNet']={}\n", + " ModelKeys['Imagen']={}\n", + " # ++++++++++++++++++++++++++++++++++++++++++++++++++\n", + " write_PK_UNet=dict()\n", + " write_PK_UNet['dim']=ModelKeys['dim'] # 256\n", + " write_PK_UNet['text_embed_dim']=ModelKeys['text_embed_dim'] # 512+32\n", + " write_PK_UNet['num_resnet_blocks']=1\n", + " write_PK_UNet['cond_dim']=ModelKeys['cond_dim'] #this is where text embeddings are projected to...\n", + " # write_PK_UNet['num_image_tokens']=None # using the default value\n", + " # write_PK_UNet['num_time_tokens']=None # using the default\n", + " # write_PK_UNet['learned_sinu_pos_emb_dim']=None\n", + " # write_PK_UNet['out_dim']=None\n", + " write_PK_UNet['dim_mults']=(1, 2, 4, 8)\n", + "\n", + " write_PK_UNet['cond_images_channels']=ModelKeys['cond_images_channels']\n", + " write_PK_UNet['channels']=DataKeys['image_channels'] # 1\n", + " write_PK_UNet['channels_out']=DataKeys['image_channels'] # 1\n", + "\n", + " write_PK_UNet['attn_dim_head']=64\n", + " write_PK_UNet['attn_heads']=8\n", + " write_PK_UNet['ff_mult']=2.\n", + " write_PK_UNet['lowres_cond']=False # for cascading diffusion - https://cascaded-diffusion.github.io/\n", + "\n", + " write_PK_UNet['layer_attns']=(False, True, True, False)\n", + " write_PK_UNet['layer_attns_depth']=1\n", + " write_PK_UNet['layer_attns_add_text_cond']=True # whether to condition the self-attention blocks with the text embeddings, as described in Appendix D.3.1\n", + " write_PK_UNet['attend_at_middle']=True # whether to have a layer of attention at the bottleneck (can turn off for higher resolution in cascading DDPM, before bringing in efficient attention)\n", + " write_PK_UNet['layer_cross_attns']=(False, True, True, False)\n", + " write_PK_UNet['use_linear_attn']=False\n", + " write_PK_UNet['use_linear_cross_attn']=False\n", + "\n", + " write_PK_UNet['cond_on_text']=True\n", + " write_PK_UNet['max_text_len']=ModelKeys['max_text_len'] # need to check this one\n", + " # ModelKeys['UNet']['init_dim']=None\n", + " write_PK_UNet['resnet_groups']=8\n", + " write_PK_UNet['init_conv_kernel_size']=7 # kernel size of initial conv, if not using cross embed\n", + " write_PK_UNet['init_cross_embed']=False #TODO - fix ouput size calcs for conv1d\n", + " write_PK_UNet['init_cross_embed_kernel_sizes']=(3, 7, 15)\n", + " write_PK_UNet['cross_embed_downsample']=False\n", + " write_PK_UNet['cross_embed_downsample_kernel_sizes']=(2, 4)\n", + "\n", + " write_PK_UNet['attn_pool_text']=True\n", + " write_PK_UNet['attn_pool_num_latents']=32 #perceiver model latents\n", + " write_PK_UNet['dropout']=0.\n", + " write_PK_UNet['memory_efficient']=False\n", + " write_PK_UNet['init_conv_to_final_conv_residual']=False\n", + "\n", + " write_PK_UNet['use_global_context_attn']=True\n", + " write_PK_UNet['scale_skip_connection']=True\n", + " write_PK_UNet['final_resnet_block']=True\n", + " write_PK_UNet['final_conv_kernel_size']=3\n", + "\n", + " write_PK_UNet['cosine_sim_attn']=True\n", + " write_PK_UNet['self_cond']=False\n", + " write_PK_UNet['combine_upsample_fmaps']=True # combine feature maps from all upsample blocks, used in unet squared successfully\n", + " write_PK_UNet['pixel_shuffle_upsample']=False # may address checkboard artifacts\n", + " # write_PK_UNet['beginning_and_final_conv_present']=None # use default\n", + " ModelKeys['UNet']=UtilityPack.prepare_UNet_keys(write_PK_UNet)\n", + " # +++++++++++++++++++++++++++++++++++++++++++++++++++++\n", + " # beyond UNet, for Whole model, all keys\n", + " # \"None\" means defult value on function definition\n", + " write_PK_Imagen=dict()\n", + "\n", + " write_PK_Imagen['timesteps']=ModelKeys['diff_timesteps']\n", + " write_PK_Imagen['dim']=ModelKeys['dim']\n", + " write_PK_Imagen['pred_dim']=ModelKeys['pred_dim']\n", + " write_PK_Imagen['loss_type']=ModelKeys['loss_type'] # 0 # MSE\n", + " write_PK_Imagen['elucidated']=ModelKeys['elucidated'] # True\n", + " write_PK_Imagen['padding_idx']=ModelKeys['padding_idx'] # 0 # need to check\n", + " # write_PK_Imagen['cond_dim']=None # use default\n", + " # write_PK_Imagen['text_embed_dim']=None\n", + " # write_PK_Imagen['input_tokens']=None\n", + " # write_PK_Imagen['sequence_embed']=None\n", + " # write_PK_Imagen['embed_dim_position']=None\n", + " write_PK_Imagen['max_text_len']=ModelKeys['max_text_len']\n", + " write_PK_Imagen['cond_images_channels']=ModelKeys['cond_images_channels']\n", + " write_PK_Imagen['max_length']=ModelKeys['max_length']\n", + " write_PK_Imagen['device']=ModelKeys['device']\n", + "\n", + " # extend it to a full key\n", + " ModelKeys['Imagen']=UtilityPack.prepare_ModelB_keys(write_PK_Imagen)\n", + " # to be defined\n", + "\n", + "\n", + " # --\n", + " print(\"==================================================\")\n", + " print(\"store the MODEL key for the next-time usage\")\n", + " print(\"==================================================\")\n", + " model_pack = {}\n", + " model_pack['ModelKeys']=ModelKeys\n", + " with open(PKeys['pk_model_pack'], 'wb') as handle:\n", + " pickle.dump(model_pack, handle, protocol=pickle.HIGHEST_PROTOCOL)\n", + "\n", + " print(\"Done.\")\n", + "\n", + "\n", + "else: # both for training and testing\n", + " #\n", + " print(\"==================================================\")\n", + " print(\"load in the MODEL key from the previous storage\")\n", + " print(\"==================================================\")\n", + " #\n", + " # this is not the first run\n", + " print('This is not the first run')\n", + " print('Load back in the model packages...')\n", + " with open(PKeys['pk_model_pack'], 'rb') as handle:\n", + " model_pack = pickle.load(handle)\n", + " # deliver the results\n", + " ModelKeys=model_pack['ModelKeys']\n", + " print('Done.')\n", + "\n", + "\n", + "# print(DataKeys)\n", + "# check a few key words\n", + "# print (DataKeys['max_text_len'])\n", + "# print(DataKeys['max_text_len'])\n", + "print(ModelKeys['max_text_len'])\n", + "print(DataKeys['image_channels'])\n", + "print(ModelKeys['cond_images_channels'])\n", + "print(ModelKeys['pred_dim'])\n", + "print(json.dumps(ModelKeys['UNet'], indent=4))\n", + "# print(json.dumps(ModelKeys['Imagen'], indent=4))\n", + "print(ModelKeys['Imagen'])\n", + "\n", + "# select some key values\n", + "print(ModelKeys['UNet']['channels'])\n", + "print(ModelKeys['UNet']['channels_out'])\n", + "print(ModelKeys['UNet']['cond_images_channels'])\n", + "print(ModelKeys['Imagen']['pred_dim'])\n", + "print(ModelKeys['Imagen']['cond_images_channels'])\n", + "# how large the model will be\n", + "print()\n", + "print(ModelKeys['UNet']['dim'])\n", + "print(ModelKeys['Imagen']['dim'])\n", + "# =====================================\n", + "# setup the model\n", + "# =====================================\n", + "if CKeys['Problem_ID']==1 or CKeys['Problem_ID']==2:\n", + " pass\n", + "# # =================================================\n", + "# # Resideual level tasks: Model B\n", + "# # =================================================\n", + "\n", + "# # working code: assemble the model archi\n", + "# print('--------------------------------------------')\n", + "# print('On OneD_Unet...')\n", + "# print('--------------------------------------------')\n", + "# working_unet = ModelPack.OneD_Unet(\n", + "# CKeys=CKeys,\n", + "# PKeys=ModelKeys['UNet'],\n", + "# ).to(device)\n", + "\n", + "# print(\"Working unet part model: \")\n", + "# UtilityPack.params ( working_unet)\n", + "\n", + "# print('--------------------------------------------')\n", + "# print('On whole model...')\n", + "# print('--------------------------------------------')\n", + "# # on the model part\n", + "# working_model = ModelPack.ProteinDesigner_B(\n", + "# working_unet,\n", + "# CKeys=CKeys,\n", + "# PKeys=ModelKeys['Imagen'],\n", + "# ). to(device)\n", + "\n", + "# # measure\n", + "# print (\"Total working model: \")\n", + "# UtilityPack.params ( working_model)\n", + "# print (\"Recasted unet inside the tot one only: \")\n", + "# UtilityPack.params ( working_model.imagen.unets[0])\n", + "\n", + "# print('--------------------------------------------')\n", + "# print('On trainer...')\n", + "# print('--------------------------------------------')\n", + "# working_trainer = TrainerPack.ImagenTrainer(\n", + "# working_model,\n", + "# CKeys=CKeys\n", + "# )\n", + "\n", + "elif CKeys['Problem_ID']==3 or CKeys['Problem_ID']==4:\n", + " pass\n", + "# # =================================================\n", + "# # Sequence level tasks: Model A\n", + "# # =================================================\n", + "\n", + "# # working code: assemble the model archi\n", + "# print('--------------------------------------------')\n", + "# print('On OneD_Unet...')\n", + "# print('--------------------------------------------')\n", + "# working_unet = ModelPack.OneD_Unet(\n", + "# CKeys=CKeys,\n", + "# PKeys=ModelKeys['UNet'],\n", + "# ).to(device)\n", + "\n", + "# print(\"Working unet part model: \")\n", + "# UtilityPack.params ( working_unet)\n", + "\n", + "# print('--------------------------------------------')\n", + "# print('On whole model...')\n", + "# print('--------------------------------------------')\n", + "# # on the model part\n", + "# working_model = ModelPack.ProteinDesigner_A_II(\n", + "# working_unet,\n", + "# CKeys=CKeys,\n", + "# PKeys=ModelKeys['Imagen'],\n", + "# ). to(device)\n", + "\n", + "# # measure\n", + "# print (\"Total working model: \")\n", + "# UtilityPack.params ( working_model)\n", + "# print (\"Recasted unet inside the tot one only: \")\n", + "# UtilityPack.params ( working_model.imagen.unets[0])\n", + "\n", + "# print('--------------------------------------------')\n", + "# print('On trainer...')\n", + "# print('--------------------------------------------')\n", + "# working_trainer = TrainerPack.ImagenTrainer(\n", + "# working_model,\n", + "# CKeys=CKeys\n", + "# )\n", + "\n", + "elif CKeys['Problem_ID']==5 or CKeys['Problem_ID']==6 \\\n", + "or CKeys['Problem_ID']==11:\n", + " # =================================================\n", + " # Resideual level tasks: Model B\n", + " # =================================================\n", + "\n", + " # working code: assemble the model archi\n", + " print('--------------------------------------------')\n", + " print('On OneD_Unet...')\n", + " print('--------------------------------------------')\n", + " working_unet = ModelPack.OneD_Unet(\n", + " CKeys=CKeys,\n", + " PKeys=ModelKeys['UNet'],\n", + " ).to(device)\n", + "\n", + " print(\"Working unet part model: \")\n", + " UtilityPack.params ( working_unet)\n", + "\n", + " print('--------------------------------------------')\n", + " print('On whole model...')\n", + " print('--------------------------------------------')\n", + " # on the model part\n", + " working_model = ModelPack.ProteinDesigner_B(\n", + " working_unet,\n", + " CKeys=CKeys,\n", + " PKeys=ModelKeys['Imagen'],\n", + " ). to(device)\n", + "\n", + " # measure\n", + " print (\"Total working model: \")\n", + " UtilityPack.params ( working_model)\n", + " print (\"Recasted unet inside the tot one only: \")\n", + " UtilityPack.params ( working_model.imagen.unets[0])\n", + "\n", + " print('--------------------------------------------')\n", + " print('On trainer...')\n", + " print('--------------------------------------------')\n", + " working_trainer = TrainerPack.ImagenTrainer(\n", + " working_model,\n", + " CKeys=CKeys\n", + " )\n", + "\n", + "elif CKeys['Problem_ID']==7 or CKeys['Problem_ID']==8:\n", + " # =================================================\n", + " # Sequence level tasks: Model A\n", + " # =================================================\n", + "\n", + " # working code: assemble the model archi\n", + " print('--------------------------------------------')\n", + " print('On OneD_Unet...')\n", + " print('--------------------------------------------')\n", + " working_unet = ModelPack.OneD_Unet(\n", + " CKeys=CKeys,\n", + " PKeys=ModelKeys['UNet'],\n", + " ).to(device)\n", + "\n", + " print(\"Working unet part model: \")\n", + " UtilityPack.params ( working_unet)\n", + "\n", + " print('--------------------------------------------')\n", + " print('On whole model...')\n", + " print('--------------------------------------------')\n", + " # on the model part\n", + " working_model = ModelPack.ProteinDesigner_A_II(\n", + " working_unet,\n", + " CKeys=CKeys,\n", + " PKeys=ModelKeys['Imagen'],\n", + " ). to(device)\n", + "\n", + " # measure\n", + " print (\"Total working model: \")\n", + " UtilityPack.params ( working_model)\n", + " print (\"Recasted unet inside the tot one only: \")\n", + " UtilityPack.params ( working_model.imagen.unets[0])\n", + "\n", + " print('--------------------------------------------')\n", + " print('On trainer...')\n", + " print('--------------------------------------------')\n", + " working_trainer = TrainerPack.ImagenTrainer(\n", + " working_model,\n", + " CKeys=CKeys\n", + " )\n", + "\n", + "\n", + "\n", + "del working_unet\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "oP6SZ_omkf8k", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "oP6SZ_omkf8k", + "outputId": "3c3f857f-fc29-409a-919d-f6008ef96f88" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Check tokenizer_X: None\n", + "tokenizer_y: None\n" + ] + } + ], + "source": [ + "#@title ### 1.4. Training part\n", + "\n", + "if CKeys['Working_Mode']==1:\n", + " print(\"Training mode...\")\n", + "\n", + " TrainKeys={}\n", + " if CKeys['Debug']==1:\n", + " TrainKeys['epochs']=4\n", + " TrainKeys['print_loss_every_this_epochs']=1\n", + " TrainKeys['sample_every_this_epochs']=1\n", + " TrainKeys['save_model_every_this_epochs']=2\n", + " else:\n", + " TrainKeys['epochs']=CKeys['epochs'] # 200\n", + " TrainKeys['print_loss_every_this_epochs']=CKeys['print_loss_every_this_epochs'] # 5\n", + " TrainKeys['sample_every_this_epochs']=CKeys['sample_every_this_epochs'] # 10\n", + " TrainKeys['save_model_every_this_epochs']=CKeys['save_model_every_this_epochs'] # 20\n", + "\n", + "# one mini batch\n", + "if CKeys['Debug']==1 and CKeys['Debug_DataPack']==1:\n", + " print(\"in a mini-batch:\")\n", + " print(\"input.dim: \", this_item[0].shape)\n", + " # print(this_item[0][0,:]*torch.FloatTensor(DataKeys['Xnormfac']))\n", + " print(\"output.dim: \", this_item[1].shape)\n", + " print(DataKeys['Xnormfac'])\n", + "\n", + "if CKeys['Working_Mode']==1:\n", + " # ==============================================================\n", + " # copy from the above when debug is done:\n", + " # ==============================================================\n", + " # a few files for restarts:\n", + " TRAINING_HIST_FILE = ModelKeys['model_dir']+'Training_Hist.csv'\n", + " TRAINING_HIST_FILE_FULL = ModelKeys['model_dir']+'Training_Hist_Full.csv'\n", + " TRAINING_BREAK_POINT = ModelKeys['model_dir']+'Training_Info.txt'\n", + "\n", + " if CKeys['Problem_ID']==1:\n", + " pass\n", + " # # de novo test\n", + " # test_condition_list = [\n", + " # ['~~~HHHHHHHHHHHHHHH~~'],\n", + " # ['~~EEESSTTS~SEEEEEEEEE~SBS~EEEEEE~~'],\n", + " # ]\n", + "\n", + " elif CKeys['Problem_ID']==2:\n", + " pass\n", + "\n", + " # test_condition_list = [\n", + " # np.expand_dims(np.array(DataSetPack.pad_a_np_arr(protein_df['sample_NormPullGap_data'][pick_id_0],0,64))*DataKeys['Xnormfac']*0.33, axis=0),\n", + " # np.expand_dims(np.array(DataSetPack.pad_a_np_arr(protein_df['sample_NormPullGap_data'][pick_id_0],0,64))*DataKeys['Xnormfac']*0.66, axis=0),\n", + " # ]\n", + "\n", + " # de novo test\n", + " elif CKeys['Problem_ID']==3:\n", + " pass\n", + "\n", + " # test_condition_list = [\n", + " # [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1],\n", + " # [0, 0.7, 0.07, 0.1, 0.01, 0.02, 0.01, 0.11],\n", + " # ]\n", + "\n", + " elif CKeys['Problem_ID']==4:\n", + " pass\n", + "\n", + " # # here we used normalized (nFmax, nToughness)\n", + " # # the real values will be (nFmax, nToughness)*Xnormfac\n", + " # test_condition_list = [\n", + " # [0.5, 0.5],\n", + " # [0.2, 0.8],\n", + " # ]\n", + "\n", + " # # #\n", + " # # test_condition_list = [\n", + " # # np.expand_dims(np.array(this_item[0][10,:]*DataKeys['Xnormfac']), axis=0),\n", + " # # np.expand_dims(np.array(this_item[0][20,:]*DataKeys['Xnormfac']), axis=0),\n", + " # # ]\n", + " # # protein_df['sample_NormPullGap_data'][pick_id_0]\n", + " # # DataSetPack.pad_a_np_arr(protein_df['sample_NormPullGap_data'][pick_id_0],0,64)\n", + " # # #\n", + " # test_condition_list = [\n", + " # np.expand_dims(np.array(DataSetPack.pad_a_np_arr(protein_df['sample_NormPullGap_data'][pick_id_0],0,64))*DataKeys['Xnormfac']*0.33, axis=0),\n", + " # np.expand_dims(np.array(DataSetPack.pad_a_np_arr(protein_df['sample_NormPullGap_data'][pick_id_0],0,64))*DataKeys['Xnormfac']*0.66, axis=0),\n", + " # ]\n", + " elif CKeys['Problem_ID']==5:\n", + " pass\n", + "\n", + " # # de novo test\n", + " # test_condition_list = [\n", + " # ['~~~HHHHHHHHHHHHHHH~~'],\n", + " # ['~~EEESSTTS~SEEEEEEEEE~SBS~EEEEEE~~'],\n", + " # ]\n", + "\n", + " #\n", + " elif CKeys['Problem_ID']==6 or CKeys['Problem_ID']==11:\n", + " # for ESM model: 0+content+00\n", + " # test_condition_list = [\n", + " # np.expand_dims(np.array([0]+DataSetPack.pad_a_np_arr(protein_df['sample_NormPullGap_data'][pick_id_0],0,64-1))*DataKeys['Xnormfac']*0.33, axis=0),\n", + " # np.expand_dims(np.array([0]+DataSetPack.pad_a_np_arr(protein_df['sample_NormPullGap_data'][pick_id_0],0,64-1))*DataKeys['Xnormfac']*0.66, axis=0),\n", + " # ]\n", + " #\n", + " # test_condition_list = [\n", + " # np.insert(np.array(DataSetPack.pad_a_np_arr(protein_df['sample_NormPullGap_data'][pick_id_0],0,64-1))*DataKeys['Xnormfac']*0.33, 0, 0.),\n", + " # np.insert(np.array(DataSetPack.pad_a_np_arr(protein_df['sample_NormPullGap_data'][pick_id_0],0,64-1))*DataKeys['Xnormfac']*0.66, 0, 0.),\n", + " # ]\n", + " #\n", + " test_0 = DataSetPack.pad_a_np_arr(\n", + " protein_df['sample_FORCE_data'][pick_id_0],\n", + " 0.,\n", + " DataKeys['max_AA_seq_len']\n", + " )\n", + " test_1 = DataSetPack.pad_a_np_arr_esm(\n", + " protein_df['sample_FORCE_data'][pick_id_1],\n", + " 0.,\n", + " DataKeys['max_AA_seq_len']\n", + " )\n", + " # test_condition_list = [\n", + " # test_0*0.33,\n", + " # test_0*0.66,\n", + " # test_1*0.33,\n", + " # test_1*0.66,\n", + " # ]\n", + " test_condition_list = [\n", + " test_0*0.66,\n", + " test_1*1.66,\n", + " ]\n", + "\n", + "\n", + " #\n", + " # de novo test\n", + " elif CKeys['Problem_ID']==7:\n", + " pass\n", + "\n", + " # test_condition_list = [\n", + " # [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1],\n", + " # [0, 0.7, 0.07, 0.1, 0.01, 0.02, 0.01, 0.11],\n", + " # ]\n", + "\n", + " elif CKeys['Problem_ID']==8:\n", + "\n", + " test_condition_list = [\n", + " [0.2, 0.8]*DataKeys['Xnormfac'],\n", + " [0.8, 0.2]*DataKeys['Xnormfac'],\n", + " ]\n", + "\n", + "\n", + " else:\n", + " print(\"No de novo condition is found for the problem...\")\n", + "\n", + "\n", + "\n", + "print('Check tokenizer_X:', tokenizer_X)\n", + "print('tokenizer_y:', tokenizer_y)\n", + "# skip training part" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "k65qjerclFxn", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "k65qjerclFxn", + "outputId": "1b865311-7268-4a5d-8570-19c7a4c37711" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "This is testing model...\n", + "Creating the given path...\n", + "Done.\n", + "/content/working_results/\n", + "Load back the saved model...\n", + "checkpoint loaded from /content/working_results/1_model_SS/trainer_save-model_pLDM.pt\n", + "11\n", + "esm2_t30_150M_UR50D\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Downloading: \"https://dl.fbaipublicfiles.com/fair-esm/models/esm2_t30_150M_UR50D.pt\" to /root/.cache/torch/hub/checkpoints/esm2_t30_150M_UR50D.pt\n", + "Downloading: \"https://dl.fbaipublicfiles.com/fair-esm/regression/esm2_t30_150M_UR50D-contact-regression.pt\" to /root/.cache/torch/hub/checkpoints/esm2_t30_150M_UR50D-contact-regression.pt\n" + ] + } + ], + "source": [ + "#@title ### 1.5. Testing loop\n", + "\n", + "if CKeys['Working_Mode']==2:\n", + " print(\"This is testing model...\")\n", + " # setup test key\n", + " TestKeys={}\n", + " TestKeys['Sample_On_TestSet']=False # True # True # False\n", + " TestKeys['Sample_On_DeNovo']=True\n", + " # create a test dir\n", + " # TestKeys['test_dir']=PKeys['prefix']+'2_test/'\n", + " # TestKeys['test_dir']=PKeys['prefix']+'3_test_common_denovo/'\n", + " # add for colab\n", + " TestKeys['test_dir']=PKeys['prefix']+'4_test_individual_cases/'\n", + " UtilityPack.create_path(TestKeys['test_dir'])\n", + "print(PKeys['prefix'])\n", + "\n", + "\n", + "if CKeys['Working_Mode']==2:\n", + " # skip for colab inferring\n", + " pass\n", + " # # looking back at the training\n", + " # print(\"Check the training history...\")\n", + " # #\n", + " # # training history\n", + " # TRAINING_HIST_FILE = ModelKeys['model_dir']+'Training_Hist.csv'\n", + " # TRAINING_HIST_FILE_FULL = ModelKeys['model_dir']+'Training_Hist_Full.csv'\n", + " # TRAINING_BREAK_POINT = ModelKeys['model_dir']+'Training_Info.txt'\n", + "\n", + " # # pick up the leftover info\n", + " # # train_rec = pd.read_csv(TRAINING_HIST_FILE)\n", + " # train_rec = pd.read_csv(TRAINING_HIST_FILE_FULL)\n", + " # #\n", + " # id_best_loss = np.argmin(train_rec['norm_loss'])\n", + " # best_epoch = train_rec['epoch'][id_best_loss]\n", + " # # print(best_epoch)\n", + " # print(f\"Best epoch: {best_epoch}; LOSS: {train_rec['norm_loss'][id_best_loss]}\", )\n", + "\n", + " # fig = plt.figure()\n", + " # plt.plot(\n", + " # train_rec['epoch'],\n", + " # train_rec['norm_loss'],\n", + " # label='Loss',\n", + " # )\n", + " # plt.legend()\n", + " # outname=TestKeys['test_dir']+\"0_Training_Hist.jpg\"\n", + " # if CKeys['SlientRun']==1:\n", + " # plt.savefig(outname, dpi=200)\n", + " # else:\n", + " # pass\n", + " # plt.show()\n", + " # plt.close(fig)\n", + "\n", + " # #\n", + " # # pick up the breaking point of last time\n", + " # breaking_rec = pd.read_csv(TRAINING_BREAK_POINT)\n", + " # last_epoch = breaking_rec['epoch'][0]\n", + " # last_step = breaking_rec['steps'][0]\n", + " # # print(\"Last epoch: \", breaking_rec['epoch'][0])\n", + " # print(f\"Last epoch: {last_epoch}; LOSS: {breaking_rec['norm_loss'][0]}\", )\n", + " #\n", + " # last_epoch = 4000\n", + " # last_step = 92000\n", + "\n", + "\n", + "if CKeys['Working_Mode']==2:\n", + " print(\"Load back the saved model...\")\n", + " # load back the LAST model:\n", + " # model_last_fname=f\"{ModelKeys['model_dir_model']}trainer_save-model-epoch_{last_epoch}.pt\"\n", + " model_last_fname=f\"{this_working_path}1_model_SS/trainer_save-model_pLDM.pt\"\n", + " working_trainer.load(model_last_fname)\n", + " # TBA: load back the Best model AVAILABLE\n", + "\n", + "print(CKeys['Problem_ID'])\n", + "print(DataKeys['ESM-2_Model'])\n", + "# +++++++++++++++++++++++++++++++++++++++++++++\n", + "# for pLM models, we need to add the\n", + "# pretrained pLM model\n", + "# +++++++++++++++++++++++++++++++++++++++++++++\n", + "if CKeys['Working_Mode']==2:\n", + " #\n", + " if CKeys['Problem_ID']==5 or CKeys['Problem_ID']==6 \\\n", + " or CKeys['Problem_ID']==11 :\n", + " pLM_Model_Name=DataKeys['ESM-2_Model']\n", + "# # --\n", + "# import esm\n", + "# # make this into a function\n", + "# # ++ for pLM\n", + "# if pLM_Model_Name=='None':\n", + "# pLM_Model=None\n", + "\n", + "# elif pLM_Model_Name=='esm2_t33_650M_UR50D':\n", + "# # dim: 1280\n", + "# pLM_Model, esm_alphabet = esm.pretrained.esm2_t33_650M_UR50D()\n", + "# len_toks=len(esm_alphabet.all_toks)\n", + "# pLM_Model.eval()\n", + "# pLM_Model. to(device)\n", + "\n", + "# elif pLM_Model_Name=='esm2_t36_3B_UR50D':\n", + "# # dim: 2560\n", + "# esm_layer=36\n", + "# pLM_Model, esm_alphabet = esm.pretrained.esm2_t36_3B_UR50D()\n", + "# len_toks=len(esm_alphabet.all_toks)\n", + "# pLM_Model.eval()\n", + "# pLM_Model. to(device)\n", + "\n", + "# elif pLM_Model_Name=='esm2_t30_150M_UR50D':\n", + "# # dim: 640\n", + "# esm_layer=30\n", + "# pLM_Model, esm_alphabet = esm.pretrained.esm2_t30_150M_UR50D()\n", + "# len_toks=len(esm_alphabet.all_toks)\n", + "# pLM_Model.eval()\n", + "# pLM_Model. to(device)\n", + "\n", + "# elif pLM_Model_Name=='esm2_t12_35M_UR50D':\n", + "# # dim: 480\n", + "# esm_layer=12\n", + "# pLM_Model, esm_alphabet = esm.pretrained.esm2_t12_35M_UR50D()\n", + "# len_toks=len(esm_alphabet.all_toks)\n", + "# pLM_Model.eval()\n", + "# pLM_Model. to(device)\n", + "\n", + "# else:\n", + "# print(\"pLM model is missing...\")\n", + " pLM_Model,esm_alphabet,_,_ = UtilityPack.load_in_pLM(\n", + " pLM_Model_Name,\n", + " device\n", + " )\n" + ] + }, + { + "cell_type": "code", + "source": [ + "# # !ls /content/working_results/1_model_SS/\n", + "# file_exists = os.path.exists(\"/content/working_results/1_model_SS/trainer_save-model_pLDM.pt\")\n", + "# print(file_exists)\n", + "# !ls /content/working_results/1_model_SS/\n", + "# print(os.path.exists(\"/content/working_results/1_model_SS/trainer_save-model_pLDM.pt\"))\n", + "\n", + "# print(os.path.exists(\"../../root/.cache/huggingface/hub/models--Bo-Ni--ProteinMechanicsDiffusionDesign_BetaTest/blobs/6e2183a97418f5b77e5d5ccbd0a5adcf6c520dda0d36cb0b55555a7ac0bc3a2c\"))" + ], + "metadata": { + "id": "rWcj89Rxlhm4" + }, + "id": "rWcj89Rxlhm4", + "execution_count": 18, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# !ls /content/working_results/1_model_SS/trainer_save-model_pLDM.pt\n", + "# print(os.path.exists(\"/content/working_results/1_model_SS/trainer_save-model_pLDM.pt\"))" + ], + "metadata": { + "id": "I30fP0v5mmUO" + }, + "id": "I30fP0v5mmUO", + "execution_count": 19, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "LbFnbaCB2A7H", + "metadata": { + "cellView": "form", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000, + "referenced_widgets": [ + "b1063f05bded44b8b81e65644d9327dc", + "c10b34b4e90541cea5a992a5ce08622c", + "d5729cd0f5564f6f89379dd8c19342b3", + "006aacca0dc5492d85e564ed103a67a6", + "2c49f4aecad54c0b94f02ba53c421d72", + "0cc7b34cd24541259ee452668e509ee1", + "58357213c566489f9bd273bb2fc379e3", + "7649557e264b4652a66bcbbe80c733d7", + "f313949895864eceaa883a24f4d5cd50", + "142c2882d70f4e4fb3b745f7c6aea4a6", + "09529ba57fa14da08fbdf0fdacf8d57a", + "9941323d83d14c028518d172e6c78026", + "f221312d70d5426780dc5080ddf99eba", + "1916469bb9d34c268917db8a32b83fad", + "801cef6fec3743aa845672e01ed2b08e", + "09328d4991e84294a37839f3bcdb165d", + "d82139981f4843ae82b492ea29640ba6", + "cc54c1bec4984a57b71d6911006885f5", + "64268382856c4859bc45e5127fa0fbaa", + "fb999a48d3794d7a8e874b6c94be4aef", + "dd37e86c809446da9d3f50f4aa08197b", + "d996d94ee547475188640f6a8de9f867" + ] + }, + "id": "LbFnbaCB2A7H", + "outputId": "223e6c61-6e23-4d65-9751-8bc85b9c822f" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Run sampling on De Novo inputs set...\n", + "Loading back a common de novo tests: \n", + "Get de novo tests #: 8\n", + "On the inputs:\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Now, make design based on the inputs...\n", + "\n", + "\n", + "\n", + "Producing 2 samples...from image conditingig x_data ...\n", + "Input contents:\n", + "cond_img condition: x_data=\n", + " [array([ 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. ,\n", + " 18.28863362, 80.0692019 , 138.13979123, 139.44611167,\n", + " 129.23179473, 124.99945748, 147.03594515, 154.26267409,\n", + " 85.748749 , 94.74763505, 127.92603341, 123.13805332,\n", + " 99.12313939, 146.59346182, 165.770035 , 193.86780985,\n", + " 214.00913136, 230.90415894, 285.97514621, 220.28478982,\n", + " 165.21657777, 140.97041526, 160.604996 , 182.73803652,\n", + " 159.35024788, 149.0699255 , 150.54626136, 148.51384136,\n", + " 141.537062 , 178.25737158, 183.89341758, 187.809765 ,\n", + " 179.40302 , 167.89063924, 145.78564655, 130.70708892,\n", + " 156.36648317, 138.20652636, 134.73462406, 99.97278411,\n", + " 119.99524355, 175.66467083, 201.65559424, 212.72502818,\n", + " 187.39930591, 153.31598397, 134.58059364, 195.43962833,\n", + " 201.50041515, 198.09182045, 181.17193439, 175.74727894,\n", + " 156.24546282, 153.27967029, 149.26799638, 144.94954964,\n", + " 138.48748241, 154.92514391, 179.62173 , 185.41952212,\n", + " 194.21023345, 183.58478745, 157.48736061, 156.53251552,\n", + " 171.67232909, 158.94420333, 176.64668212, 154.79523564,\n", + " 167.48380455, 189.05203 , 173.74290091, 186.28143273,\n", + " 214.02058894, 215.24586955, 219.26901409, 213.58790242,\n", + " 200.20914818, 223.59095136, 212.30616773, 233.90132136,\n", + " 228.09856667, 222.87644909, 256.01106682, 250.59852318,\n", + " 243.01985182, 292.44150727, 284.88984348, 284.51895106,\n", + " 295.07615818, 332.62036364, 365.2915753 , 382.064295 ]), array([ 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. ,\n", + " 12.19242241, 53.37946793, 92.09319415, 92.96407444,\n", + " 86.15452982, 83.33297166, 98.02396343, 102.84178273,\n", + " 57.16583267, 63.16509003, 85.28402227, 82.09203555,\n", + " 66.08209293, 97.72897455, 110.51335667, 129.24520657,\n", + " 142.67275424, 153.93610596, 190.65009747, 146.85652655,\n", + " 110.14438518, 93.98027684, 113.26618295, 130.32051743,\n", + " 115.21384005, 109.95814935, 111.50363362, 112.12047879,\n", + " 110.6379971 , 139.25401676, 147.61078685, 144.61681044,\n", + " 135.93508952, 133.8414882 , 112.20370803, 105.51703962,\n", + " 126.78428185, 115.69128733, 114.14739412, 86.50069256,\n", + " 97.78519682, 137.55264183, 161.15336059, 169.76223629,\n", + " 154.79631037, 136.03060112, 129.56109911, 159.6066976 ,\n", + " 159.01942819, 156.89666416, 140.6024269 , 145.42806336,\n", + " 136.13430188, 133.84294094, 130.63544912, 126.44938608,\n", + " 125.60422528, 139.85916623, 153.52631933, 157.29334918,\n", + " 166.96625393, 163.38836786, 146.11630993, 156.10143063,\n", + " 169.23123586, 157.99337498, 162.88871136, 142.62287141,\n", + " 156.99899748, 176.13464122, 163.78415271, 164.45332481,\n", + " 189.85552387, 195.0109843 , 195.37009694, 189.6662509 ,\n", + " 189.36861348, 214.00427838, 213.70498551, 233.86747303,\n", + " 236.059855 , 238.31386515, 263.50758182, 255.58019414,\n", + " 242.30366399, 269.54060652, 264.16919869, 272.51291813,\n", + " 283.48890394, 310.40469131, 337.19108152, 362.22738833])]\n", + "Text condition: X_cond=\n", + " None\n", + "Working on cond_scale 1.0\n", + "Conditioning target sequence provided via x_data_tokenized ... tensor([[0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0244,\n", + " 0.1068, 0.1842, 0.1859, 0.1723, 0.1667, 0.1960, 0.2057, 0.1143, 0.1263,\n", + " 0.1706, 0.1642, 0.1322, 0.1955, 0.2210, 0.2585, 0.2853, 0.3079, 0.3813,\n", + " 0.2937, 0.2203, 0.1880, 0.2141, 0.2437, 0.2125, 0.1988, 0.2007, 0.1980,\n", + " 0.1887, 0.2377, 0.2452, 0.2504, 0.2392, 0.2239, 0.1944, 0.1743, 0.2085,\n", + " 0.1843, 0.1796, 0.1333, 0.1600, 0.2342, 0.2689, 0.2836, 0.2499, 0.2044,\n", + " 0.1794, 0.2606, 0.2687, 0.2641, 0.2416, 0.2343, 0.2083, 0.2044, 0.1990,\n", + " 0.1933, 0.1846, 0.2066, 0.2395, 0.2472, 0.2589, 0.2448, 0.2100, 0.2087,\n", + " 0.2289, 0.2119, 0.2355, 0.2064, 0.2233, 0.2521, 0.2317, 0.2484, 0.2854,\n", + " 0.2870, 0.2924, 0.2848, 0.2669, 0.2981, 0.2831, 0.3119, 0.3041, 0.2972,\n", + " 0.3413, 0.3341, 0.3240, 0.3899, 0.3799, 0.3794, 0.3934, 0.4435, 0.4871,\n", + " 0.5094, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,\n", + " 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,\n", + " 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,\n", + " 0.0000, 0.0000],\n", + " [0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0163,\n", + " 0.0712, 0.1228, 0.1240, 0.1149, 0.1111, 0.1307, 0.1371, 0.0762, 0.0842,\n", + " 0.1137, 0.1095, 0.0881, 0.1303, 0.1474, 0.1723, 0.1902, 0.2052, 0.2542,\n", + " 0.1958, 0.1469, 0.1253, 0.1510, 0.1738, 0.1536, 0.1466, 0.1487, 0.1495,\n", + " 0.1475, 0.1857, 0.1968, 0.1928, 0.1812, 0.1785, 0.1496, 0.1407, 0.1690,\n", + " 0.1543, 0.1522, 0.1153, 0.1304, 0.1834, 0.2149, 0.2263, 0.2064, 0.1814,\n", + " 0.1727, 0.2128, 0.2120, 0.2092, 0.1875, 0.1939, 0.1815, 0.1785, 0.1742,\n", + " 0.1686, 0.1675, 0.1865, 0.2047, 0.2097, 0.2226, 0.2179, 0.1948, 0.2081,\n", + " 0.2256, 0.2107, 0.2172, 0.1902, 0.2093, 0.2348, 0.2184, 0.2193, 0.2531,\n", + " 0.2600, 0.2605, 0.2529, 0.2525, 0.2853, 0.2849, 0.3118, 0.3147, 0.3178,\n", + " 0.3513, 0.3408, 0.3231, 0.3594, 0.3522, 0.3634, 0.3780, 0.4139, 0.4496,\n", + " 0.4830, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,\n", + " 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,\n", + " 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,\n", + " 0.0000, 0.0000]]) torch.Size([2, 128])\n", + "x_data.dim provided from x_data_tokenized: torch.Size([2, 33, 128])\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "0it [00:00, ?it/s]" + ], + "application/vnd.jupyter.widget-view+json": { + "version_major": 2, + "version_minor": 0, + "model_id": "b1063f05bded44b8b81e65644d9327dc" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "sampling time step: 0%| | 0/96 [00:00" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "tensor([20, 20, 4, 6, 4, 7, 15, 7, 15, 11, 16, 5, 6, 4, 18, 6, 11, 4,\n", + " 6, 17, 8, 6, 17, 14, 15, 6, 7, 17, 18, 10, 5, 16, 9, 6, 6, 16,\n", + " 14, 21, 19, 7, 11, 10, 10, 13, 13, 19, 15, 6, 5, 15, 7, 7, 13, 7,\n", + " 15, 6, 18, 10, 14, 9, 15, 4, 5, 9, 13, 9, 9, 6, 20, 6, 7, 7,\n", + " 7, 4, 4, 10, 8, 15, 9, 6, 15, 14, 7, 12, 18, 8, 15, 14, 5, 17,\n", + " 17, 6, 4, 7, 13, 10, 12, 15, 15, 16, 8, 15, 9, 9, 9, 11, 17, 17,\n", + " 17, 4, 17, 17, 11, 17, 11, 17, 17, 11, 11, 17, 11, 17, 20, 11, 11, 4,\n", + " 11, 9], device='cuda:0')\n", + "tensor([ 5, 20, 13, 11, 4, 15, 16, 4, 5, 5, 5, 5, 18, 17, 13, 4, 5, 18,\n", + " 10, 4, 7, 8, 5, 5, 18, 4, 15, 7, 4, 10, 13, 5, 18, 4, 6, 18,\n", + " 14, 13, 15, 6, 10, 5, 5, 15, 12, 19, 19, 7, 5, 14, 13, 7, 7, 18,\n", + " 23, 23, 18, 23, 6, 14, 6, 6, 7, 16, 5, 9, 17, 6, 5, 13, 14, 14,\n", + " 19, 10, 22, 5, 17, 6, 20, 14, 8, 14, 14, 4, 7, 4, 5, 8, 15, 8,\n", + " 13, 9, 4, 11, 11, 9, 4, 15, 4, 4, 8, 9, 9, 5, 15, 17, 8, 17,\n", + " 4, 17, 17, 9, 17, 11, 11, 11, 9, 8, 17, 11, 17, 17, 17, 17, 17, 9,\n", + " 11, 9], device='cuda:0')\n", + "For None or [ 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 18.28863362 80.0692019\n", + " 138.13979123 139.44611167 129.23179473 124.99945748 147.03594515\n", + " 154.26267409 85.748749 94.74763505 127.92603341 123.13805332\n", + " 99.12313939 146.59346182 165.770035 193.86780985 214.00913136\n", + " 230.90415894 285.97514621 220.28478982 165.21657777 140.97041526\n", + " 160.604996 182.73803652 159.35024788 149.0699255 150.54626136\n", + " 148.51384136 141.537062 178.25737158 183.89341758 187.809765\n", + " 179.40302 167.89063924 145.78564655 130.70708892 156.36648317\n", + " 138.20652636 134.73462406 99.97278411 119.99524355 175.66467083\n", + " 201.65559424 212.72502818 187.39930591 153.31598397 134.58059364\n", + " 195.43962833 201.50041515 198.09182045 181.17193439 175.74727894\n", + " 156.24546282 153.27967029 149.26799638 144.94954964 138.48748241\n", + " 154.92514391 179.62173 185.41952212 194.21023345 183.58478745\n", + " 157.48736061 156.53251552 171.67232909 158.94420333 176.64668212\n", + " 154.79523564 167.48380455 189.05203 173.74290091 186.28143273\n", + " 214.02058894 215.24586955 219.26901409 213.58790242 200.20914818\n", + " 223.59095136 212.30616773 233.90132136 228.09856667 222.87644909\n", + " 256.01106682 250.59852318 243.01985182 292.44150727 284.88984348\n", + " 284.51895106 295.07615818 332.62036364 365.2915753 382.064295 ], predicted sequence: MLGLVKVKTQAGLFGTLGNSGNPKGVNFRAQEGGQPHYVTRRDDYKGAKVVDVKGFRPEKLAEDEEGMGVVVLLRSKEGKPVIFSKPANNGLVDRIKKQ\n", + "================================================\n", + "foldproteins: True\n", + "Writing FASTA file: /content/working_results/4_test_individual_cases/fasta_in_100.fasta\n", + "Now run OmegaFold.... on device=cuda:0\n", + "INFO:root:Loading weights from /root/.cache/omegafold_ckpt/model.pt\n", + "INFO:root:Constructing OmegaFold\n", + "INFO:root:Reading /content/working_results/4_test_individual_cases/fasta_in_100.fasta\n", + "INFO:root:Predicting 1th chain in /content/working_results/4_test_individual_cases/fasta_in_100.fasta\n", + "INFO:root:99 residues in this chain.\n", + "INFO:root:Finished prediction in 10.65 seconds.\n", + "INFO:root:Saving prediction to /content/working_results/4_test_individual_cases/temp_100.pdb\n", + "INFO:root:Saved\n", + "INFO:root:Done!\n", + "\n", + "Done OmegaFold\n", + "Resulting PDB file...: /content/working_results/4_test_individual_cases/temp_100.pdb\n", + "Properly named PDB file produced: /content/working_results/4_test_individual_cases/DN_0_CondS_No_0_Val_1.0_epo_100_step_100.pdb\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzcAAAAtCAYAAACTdJW6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAdXklEQVR4nO3deVxUVf8H8O8MzAwDCGKIbDK5oOLG4oIoCi5JqaFPKdZjrmSWmP5yLcMFtfKllpqPWplZZpRliVbuJCMgoY+yuCCgIosMmqACSsbA5/cHz9y8zLDppDJ8377m9ZJzzz33zNwz557vXc5IAIAYY4wxxhhjrJGTPu4KMMYYY4wxxpgxcHDDGGOMMcYYMwkc3DDGGGOMMcZMAgc3jDHGGGOMMZPAwQ1jjDHGGGPMJHBwwxhjjDHGGDMJHNwwxhhjjDHGTAIHN4wxxhhjjDGTwMENY4wxxhhjzCRwcMMYY4wxxhgzCRzcMMYYY4wxxkwCBzeMMcYYY4wxk8DBDWOMMcYYY8wkcHDDGGOMMcYYMwkc3DDGGGOMMcZMAgc3//P000/TunXrHnc12GO0dOlS8vLyeuTbHT9+PL3//vuPfLv3e+mll+jDDz98rHVoiqKjo8nDw4MqKiqMWm6fPn3oxx9/NGqZjGjAgAEUGRlp1DI/+eQTev75541aJhMDQK+99hq1aNGCJBIJJScnU2BgIP3f//1fres97nFBeno6OTo6UklJiVHL5f7+8anPOKM+bbM6iURCUVFRDa7PP9XGGuLGjRvk4OBAeXl5xisUDACgUqmwdu1a0d9EBCKChYUFVCoVxowZg+joaNF6WVlZQj4igrW1NTp37ozp06cjIyNDyBcQECDKV/0VEBBgvDdD9GhfD2jEiBEICgoyuOzYsWMgIqSkpDxw+Q21ZMkSeHp6PrLtAUBycjJatGiBkpKSBy7DUHv69ttvRXmOHj0Kb29vyOVytGvXDtu2bRMtP3PmDOzs7HDr1q0Hrsf/avOIXw9u4sSJGDly5EOV8bB8fHywY8cOUdqff/6JhQsXws3NDXK5HCqVClu3bhXl+f7779GxY0coFAp07doVv/76q2j5zz//jPbt26OiouKh6keP8N/DysnJweTJk+Hk5ASZTAY3NzfMnDkTN27cEOULCAjArFmzRGnr1q2DXC7X+97cb8+ePejQoYPwmVbv++9/ff/998J62dnZGDZsGJRKJVq2bIm5c+eivLxcWH7v3j04Ozvj2LFjD/0ZNJ5vXxWNRoMZM2agTZs2kMvlcHV1xYgRI3DkyBEjlP63ffv2QSaTIT4+HhqNBuXl5SgsLERxcXGt61UfFxiDofZXk3/9619YsWKFKO3AgQPw9fWFtbU17O3t8cILLyArK0uU51H1941hqNEYxxn1aZvVERF2797d4PoYamMNUVxcjFmzZsHNzQ0WFhbw8/PDiRMnRHkqKyuxaNEiODo6wsLCAoMHDxaNjwFgzpw5mDJlygPXozoObv7HUHCzbNkyaDQaZGdnQ61WY+rUqZBIJKKGoDvAHTlyBBqNBpcuXUJUVBQGDhwIpVIpdNKFhYXQaDTQaDQ4ceKEaB2NRoPCwkLjvZnG0OMA2L17N6RSKXJzc/WWTZ48GT179nygcu/du/dA6z2O4CY0NBTTpk1r0Dr5+fmiwRERYdu2bUJb0mg0KCsrE5ZfvnwZlpaWmD17Ns6fP48NGzbAzMwMBw4cEJXbs2dP/Oc//3m4N9SIhlePO7iJjY2Fra2taF8BQHBwMHx9fXH48GFkZWXh+PHjiIuLE5bHx8fDzMwMq1atwvnz5xEeHg6ZTIYzZ84IebRaLVq1aoVffvnloerYWIKbS5cuwcHBAf7+/oiJiUF2djb27duHLl26wN3dXdS/Vh9cLl68GJaWlti/f3+t2xg8eDA++OAD4W+tViv6zmk0GkRERMDa2lo4WaHVatG1a1cMGTIESUlJ2LdvH+zt7fHOO++Iyp47dy5Gjx79UJ8B0Ji+fVXHTmdnZ3Tu3Bm7du1Ceno6zp49iw8//BAdO3Z8yNLFNmzYADc3twav9ziDm+zsbMhkMuTl5Qlply9fhkKhwDvvvIOLFy/i1KlTGDBgALy9vUV5HlV/3xiGGk1lnPEgwY2hNlZWVobr16/Xu4yQkBB07twZarUamZmZWLJkCWxsbERlrly5Era2toiKikJKSgqCg4PRpk0b0bHv7NmzUCgURhsLN5ngJiAgAGFhYQgLC4ONjQ2eeuophIeHo7KyEoDh4MZQp7Z48WJIpVJcuHABwN/BTVJSkihfRUUFAgMDoVKpoNVqRctqWsdoGkOPA6C8vBytWrXC8uXLReklJSWwtrbG5s2bAVQNAv39/WFhYQFXV1e8+eabKC0tFfLrAtHx48ejWbNmmDhxIgYOHIiwsDBRudevX4dMJqvxrGD1TqeiogIRERFwcXGBXC6Hp6enaAD04osvirYxa9YsEBHS0tIAVHV+lpaWOHz4sMHtabVa2Nra1msAWlZWhu+++w7PPvsszMzMRGfc6urU5s+fjy5duojSxo4dq3c2KyIiAv7+/nXWpXaNZ3hVV3ATExODXr16QS6Xw9HREQsWLBCCyp9//hm2trbCdzspKQlEhAULFgjrh4aGYty4cTWWHxYWpjeg3b9/P2xtbWvt4ENCQjB8+HBRmq+vr16QPHnyZLzyyis1llMfjSW4efbZZ+Hq6oq7d++K0jUaDSwtLfH6668LabrBZWVlJWbMmIHmzZsjPj6+1vKvX78OiUSCs2fP1prPy8tLdPZx3759kEqlKCgoENI2b94MGxsb0eBIrVZDLpfr1b+hGs+3D3juuefg4uIi6st1bt68Kfw/OzsbwcHBsLKyQrNmzTBmzBjR56nrt7dv3w6VSgUbGxuMHTtWOPM9ceJE0VU1lUoFQD/IuHbtGkaMGAELCws8/fTT2LFjh9444ObNmwgNDYW9vT2aNWuGgQMHIjk5+YHrQkR6V110Vq9erTfw/uGHH2Bubi66Irt3715IJBL89ddfAB5tf98YhhpP6jijpjYC6LfN/Px8DBs2TGib33zzjV7bJCJs2bIFo0aNglKpRPv27bFnz55aPxtDbezKlSuQyWQYOXIkfvrpJ6FdGXL37l2YmZnpjWF8fHzw7rvvAqi6auPo6IjVq1cLy2/dugWFQqF3pbxNmzb4/PPPa61zfTWpZ26++uorMjc3pxMnTtD69evpo48+os8//7xBZcyaNYsA0J49e2rNJ5VKadasWZSdnU2nTp2qs9wrV66QRCKhmJiYBtWnMTM3N6cJEybQl19+SQCE9B9++IEqKiro5ZdfpkuXLtGzzz5LL774IqWmptLOnTspLi6OZsyYISprzZo15OnpSUlJSbRo0SJ69dVXKTIyku7duyfk2bFjB7m4uNCgQYPqVb/169fThx9+SGvWrKHU1FQKCgqi4OBgyszMJCKigIAA0f5Sq9Vkb28vpJ08eZLKy8upb9++BstPTU2l27dvU8+ePWusQ0JCAr3++uvk5OREs2fPpq5du1JycjLZ2tqK8oWFhZG9vT317t2bvvjiC9HnmZCQQEOGDBHlDwoKooSEBFFa79696cSJE6LPrKm6evUqDRs2jHr16kUpKSm0efNm2rp1K61YsYKIiPr3708lJSWUlJRERPr7XpcWGBhY4zZiY2P19v3evXupZ8+etGrVKnJxcaEOHTrQ3LlzqaysTMjTkP0ZGxv7IG+/USkqKqKDBw/S9OnTSalUipY5OjrSuHHjaOfOnaLvhFarpVdeeYV27dpFarW6xu+oTlxcHFlaWpKHh0eNeU6dOkXJyckUGhoqpCUkJFC3bt2oVatWQlpQUBAVFxfTuXPnhLSePXuSVqulxMTEer/vxqyoqIgOHDhAYWFhZGVlpbe8efPmRERUWVlJI0eOpKKiIlKr1XT48GG6fPkyjR07VpT/0qVLFBUVRb/88gv98ssvpFaraeXKlURU1Y8vW7aMXF1dSaPR0MmTJw3WadKkSZSbm0tHjx6lXbt20aZNm+j69euiPGPGjKHr16/T/v376dSpU+Tj40ODBw+moqKietfFz8+Ppk6dShqNhjQaDbVu3dpgfQz1Dz169CCpVErbtm2jiooKun37Nn399dc0ZMgQkslkRMT9fXVP4jijtjZiyIQJEyg/P59iYmLoxx9/pM8++0yvbRIRRUREUEhICKWmptKwYcNo3LhxorZZnaE2plKpKCEhgVQqFU2bNo2cnJxo5syZBsexWq2WKioqyMLCQpSuVCopLi6OiIiysrKooKBA1CZtbW3J19f3nz1mGSVEagQCAgLg4eEhXKkBgAULFsDDwwNA/a/cAECrVq3wxhtvAKj9KkxaWhqICDt37hSlG1onLy8PHTt2RGJi4oO9wfs1htMp/6P7jI4ePSqk9e/fXzjjHBoaitdee020TmxsLKRSqXBJU6VSYdSoUaI8ZWVlsLOzE3323bt3x9KlS2usS/UrN87OznjvvfdEeXr16oXp06cDAFJTUyGRSHD9+nUUFRVBLpdj+fLlGDt2LABgxYoV6Nu3b43b2717N8zMzERtEgByc3OxYsUKuLu7w9LSEuPGjcPBgwdrfH5i2bJliIuLw+nTp7Fy5UooFAqsX79eWO7u7o73339ftM6vv/4KIhKdKU5JSQER4cqVKzXWuW6N59xxbVduFi5ciI4dO4r2zcaNG2FtbS3sBx8fH+Fs1KhRo/Dee+9BLpejpKQEeXl5ICK9+4rvZ2tri+3bt4vSgoKCoFAoMHz4cCQmJuLXX3+FSqXCpEmThDwymQyRkZGi9TZu3AgHBwdR2p49eyCVSh/quZvGcOXm999/r/Xq5UcffQQiwrVr1wBUHQvkcjnkcrlwlbUua9euRdu2bWvN88YbbwjHE52pU6di6NChorQ7d+6AiLBv3z5Rup2dHb788st61acmjeXbl5iYCCLCTz/9VGu+Q4cOwczMDDk5OULauXPnQETCff1LliyBpaWl6Mz3vHnz4OvrK/y9du1a4YqNzv1nx9PT00VlAn8fm3TjgNjYWNjY2ODPP/8UldOuXTt8+umn9a5LfW9L8/T0xLJly/TSY2Ji4ODgADMzMxAR/Pz8RFe6HmV/31iGGk/aOKMhbURX95MnTwrLMzMzRW0TqLpyEx4eLvxdWloKIqr1dtua2phOeXk59u7di9GjRwvPd65evVp05dTPzw8BAQG4evUqtFotvv76a0ilUnTo0AFA1W3URIT8/HxR2WPGjEFISIgo7a233kJgYGCN9WmIJnXlpk+fPiSRSIS//fz8KDMzs8EzFQEQlVNbPiKqV14XFxe6cOEC9e7du0F1aew6depEffv2pS+++IKIiC5evEixsbHC2c+UlBT68ssvydraWngFBQVRZWUlZWVlCeVUP/tgYWFB48ePF8o9ffo0nT17liZNmlSvehUXF1N+fj7169dPlN6vXz9KS0sjIqKuXbtSixYtSK1WU2xsLHl7e9OIESNIrVYTUd1n7svKykihUOi1j/DwcAoPD6du3bpRbm4u7dixg4YOHUpSqeGv66JFi6hfv37k7e1NCxYsoPnz59Pq1avr9T7vpzvrfffu3Qava2rS0tLIz89PtG/69etHpaWlwowuuit3ACg2NpZeeOEF8vDwoLi4OFKr1eTs7Ezu7u41bqOsrEzvjFdlZSVJJBL65ptvqHfv3jRs2DD66KOP6KuvvhJdvakPpVJJlZWVJn9mVkfX39aHv78/WVtb06JFi0ir1daZ39C+qr48MjJSdNWmoZRKZZP57tV3X6WlpVHr1q1FVzc6d+5MzZs3F/phoqpZzZo1ayb87eTkZPDMdm3bMTc3px49eghpnTp1Eq4gEVUdi0pLS+mpp54SHY+ysrLo0qVLRquLjqE2V1BQQFOnTqWJEyfSyZMnSa1Wk1wup9GjRzeo/RM1rf7+SRtnNKSNpKenk7m5Ofn4+Ahp7du3Jzs7O7283bt3F/5vZWVFNjY2tba9uvo1c3Nzev755+mHH36grKwscnR0pHnz5tEHH3wg5Pn6668JALm4uJBCoaCPP/6YXn755RrHK7UxZh/YpIIbYygsLKQ//viD2rRpU2deXedbn7xNWWhoKP34449UUlJC27Zto3bt2lFAQAAREZWWltK0adMoOTlZeKWkpFBmZia1a9dOKMPQrQ2vvvoqHT58mPLy8mjbtm00aNAgUqlURqu3RCKhAQMGUExMjBDIdO/ene7du0dnz56l48ePC+/DEHt7e7p79y799ddfovTw8HB6++23KTExkTp06EAzZsxo0O0qvr6+lJeXJwxqHR0d6dq1a6I8165dIxsbG9FtPLrL1y1btqz3tpqywMBAiouLo5SUFJLJZNSpUycKDAwU2kNt+56oav/fvHlTlObk5EQuLi6i2w49PDwIgBBU1bQ/HR0dRWlFRUVkZWWld6uWqWnfvj1JJBLRYPd+aWlpZGdnJ2rX3bp1o+joaDp69CiNHTu2zgDH0L66365du+ju3bs0YcIEUXpN+0q37H5FRUVN5rvn7u5OEomELly4YJTydLdk6UgkEqqsrDRK2TqlpaXk5OQkOhYlJydTeno6zZs3z+h1MdTmNm7cSLa2trRq1Sry9vamAQMG0I4dOyg6Olo4RnB/b9iTNM74p9prQ8utq18DQMeOHaOpU6eSh4cHXbx4kRYvXkyzZ88W8rRr147UajWVlpZSbm4unThxgsrLy6lt27ZE9Hc/V99jlrHaY5MKbqoPEH///Xdyd3cnMzOzepexfv16kkqlNGrUqFrzVVZW0scff0xt2rQhb2/vB6lukxESEkJSqZQiIyNp+/btNGXKFOGMuY+PD50/f57at2+v95LL5bWW261bN+rZsydt2bKFIiMjacqUKfWuk42NDTk7O1N8fLwoPT4+njp37iz8rTt7HxMTQ4GBgSSVSmnAgAG0evVqunfvnt6Vn/vp5ro/f/68KL19+/b0wQcfUE5ODkVGRtLNmzdp4MCB1KFDB1q+fLnoTJIhycnJZGdnRwqFgoiqrlBGR0eL8hw+fJj8/PxEaWfPniVXV1eyt7evtfymwMPDgxISEkRnQ+Pj46lZs2bk6upKRH8/d7N27VrhIKkLbnTtoTbe3t56+75fv36Un59PpaWlQlpGRgZJpVJhuw3Zn02h73nqqafomWeeoU2bNuld3SooKKBvvvmGxo4dq3eF1MvLi6Kjo+nYsWMUEhJC5eXlNW7D29ubCgoKahwIbN26lYKDg/UOzH5+fnTmzBnR2dPDhw+TjY2NqB+5dOkS/fnnn01ifxERtWjRgoKCgmjjxo10584dveW3bt0ioqrvYW5uLuXm5grLzp8/T7du3RJ9fg+rU6dOpNVqRc8VpKenC/UgqjoWFRQUkLm5ud6xqCF9plwur9fdIob6h7t37+qdEdeNX3SDWO7vDXsSxxn10bFjR9JqtcLznURVV55qC0rqy1AbI6o65ixatIjatm1Lw4cPJ61WS1FRUXT58mWKiIggNzc3vXWsrKzIycmJbt68SQcPHqSRI0cSUdXJfUdHR1GbLC4upsTExH/2mGWUm9sagYCAAFhbW+Ott97ChQsXEBkZCSsrK3zyyScAap8KOicnRzQV9MqVK4V8hqaC3rNnjzAV9G+//aZXF37mRl9oaCjs7OxgZmaGq1evCukpKSlQKpUICwtDUlISMjIyEBUVJZqhpLbnoz777DPI5XLY2dnpTblbXfVnbtauXQsbGxt89913uHDhAhYsWACZTCZ6jiI5ORkSiQQKhUKY/nXt2rUwMzNDnz596nzfPj4+2LBhQ535bt++jS1btsDf3x9SqRS3b98GUDVTzpYtW3DmzBlkZmZi06ZNsLS0xOLFi4V1dVODzps3D2lpadi4caPBqUEnTpxohHnmG8td/1XvNzAwEElJSaJXTk4O8vLyYGlpibCwMKSlpSEqKgr29vZYsmSJqAwvLy+YmZkJM+4UFhZCJpOBiIQZFWvy8ccfo0ePHqK0kpISuLq6YvTo0Th37hzUajXc3d3x6quvCnni4+Nhbm6ONWvWIC0tDUuWLNGbChqo6vNqu5+6PhrDMzcAkJGRAXt7e/Tv3x9qtRo5OTnYv38/unbtWudU0KmpqWjZsiVGjRpV48xAWq0WLVu2xM8//6y3LDMzExKJxOC97bqpoIcOHYrk5GQcOHAALVu21JsKetu2bXU+01MfjefbVzV9t6OjozAVdEZGBs6fP4/169ejU6dOAKpmWvLy8kL//v1x6tQpJCYmokePHqLfhTM0tW71Z2zqeuYGqJpxz9vbG7///jv++9//wt/fH0qlUji2VFZWwt/fH56enjh48CCysrIQHx+PhQsXCs9D1KcuU6dORa9evZCVlYU//vijxmfi9u7dCwcHB9Fsq9HR0ZBIJIiIiEBGRgZOnTqFoKAgqFQq4XmaR9nfN7ahxpM4zgD020j1tjlkyBD4+PggMTERp0+fFsaX69atE/KQgecObW1t9X7j6H6G2lh2djakUikGDRqEr776yuBshvc7cOAA9u/fj8uXL+PQoUPw9PSEr6+vqC9duXIlmjdvjj179iA1NRUjR47Umwr6zp07UCqVRvm9L+Dh+6dGIyAgANOnT8frr78OGxsb2NnZYeHChbVOBU1UNVWjXC6Hm5sbQkJC9IKV6j/kZmlpCQ8PD0yfPh2ZmZkG62IouNGl3f/AW1Ny/PhxEBGGDRumt+zEiRN45plnYG1tDSsrK3Tv3l30oH9tnU5JSQksLS2FSQBqY2gq6KVLl8LFxQUymUxvKmhdHjs7O9HDgLppgd9+++06t7lp06Z6BUH3u3jxotBx7N+/H15eXsJn4+npiU8++UTvgHn06FF4eXlBLpejbdu2eh1eWVkZbG1tkZCQ0KC6NGaGpmUlIoSGhgKofSponerTfwNVD2k6OjrWuf3CwkJYWFjoBUFpaWkYMmQIlEolXF1dMXv2bL0pgr///nt06NABcrkcXbp00fsRz7y8PMhkMoO/7WCqrly5gokTJ6JVq1aQyWRo3bo13nzzzXr9iOeZM2fg4OCAkSNH1vj7FfPnz8dLL72kl/7OO++gdevWNQ5Sr1y5gueeew5KpRL29vaYM2eOXjsaOnSo6Dd0mor8/HyEhYVBpVJBLpfDxcUFwcHBouNgfaeCvt+DBDcajQbDhw+HQqGAm5ubMFXv/ceW4uJivPnmm3B2dhba2Lhx44QJD+pTl/T0dPTp0wdKpRJENU8FXV5eDmdnZ72g5Ntvv4W3tzesrKzQsmVLBAcH602Mwf29YU/iOAOoO7jJz8/Hc889B4VCAZVKhcjISDg4OAgn54EHC24MtbE7d+4gOzu7zvehs3PnTrRt21Y4ToaFhen9OKzuRzxbtWoFhUKBwYMHIz09XZQnMjLSqL9vJQHuu+/ChAUGBpKXlxetW7fucVeFPUJXrlyhdu3a0cmTJ0UP5D0pysrKqGPHjrRz5069S7SP0ubNm2n37t106NChx1aHpmjevHlUXFxMn376qVHLXbBgAd28eZM+++wzo5bblBUUFFCXLl3o9OnTRn1279y5czRo0CDKyMjQm+KdNW0bN26kvXv30sGDB41aLvf3xvWoxxl5eXnUunVrOnLkCA0ePPihyvqn2lhD9enTh2bOnEn//ve/jVKeuVFKYewJU15eToWFhRQeHk59+vR5IgMboqrZQbZv3043btx4rPWQyWS0YcOGx1qHpujdd9+lTZs2UWVl5QPNLlMTBwcH0UOf7OE5OjrS1q1bKScnx6jBjUajoe3bt3Ngw/RMmzaNbt26RSUlJaLZtR4W9/fG8ajGGb/99huVlpZSt27dSKPR0Pz58+npp5+mAQMGPHTZ/1Qba4gbN27QCy+8QC+//LLRyuQrN8wkxcTECA/h79q1i7p16/a4q8QYY4wxE/GoxhkHDx6kOXPm0OXLl6lZs2bUt29fWrdunVFPspiaJhPcMMYYY4wxxkxbk5oKmjHGGGOMMWa6OLhhjDHGGGOMmQQObhhjjDHGGGMmgYMbxhhjjDHGmEng4IYxxhhjjDFmEji4YYwxxhhjjJkEDm4YY4wxxhhjJoGDG8YYY4wxxphJ4OCGMcYYY4wxZhI4uGGMMcYYY4yZBA5uGGOMMcYYYyaBgxvGGGOMMcaYSeDghjHGGGOMMWYSOLhhjDHGGGOMmYT/BwIEulkpbuv7AAAAAElFTkSuQmCC\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "application/3dmoljs_load.v0": "
\n

You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension:
\n jupyter labextension install jupyterlab_3dmol

\n
\n", + "text/html": [ + "
\n", + "

You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension:
\n", + " jupyter labextension install jupyterlab_3dmol

\n", + "
\n", + "" + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "For None or [ 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 12.19242241 53.37946793\n", + " 92.09319415 92.96407444 86.15452982 83.33297166 98.02396343\n", + " 102.84178273 57.16583267 63.16509003 85.28402227 82.09203555\n", + " 66.08209293 97.72897455 110.51335667 129.24520657 142.67275424\n", + " 153.93610596 190.65009747 146.85652655 110.14438518 93.98027684\n", + " 113.26618295 130.32051743 115.21384005 109.95814935 111.50363362\n", + " 112.12047879 110.6379971 139.25401676 147.61078685 144.61681044\n", + " 135.93508952 133.8414882 112.20370803 105.51703962 126.78428185\n", + " 115.69128733 114.14739412 86.50069256 97.78519682 137.55264183\n", + " 161.15336059 169.76223629 154.79631037 136.03060112 129.56109911\n", + " 159.6066976 159.01942819 156.89666416 140.6024269 145.42806336\n", + " 136.13430188 133.84294094 130.63544912 126.44938608 125.60422528\n", + " 139.85916623 153.52631933 157.29334918 166.96625393 163.38836786\n", + " 146.11630993 156.10143063 169.23123586 157.99337498 162.88871136\n", + " 142.62287141 156.99899748 176.13464122 163.78415271 164.45332481\n", + " 189.85552387 195.0109843 195.37009694 189.6662509 189.36861348\n", + " 214.00427838 213.70498551 233.86747303 236.059855 238.31386515\n", + " 263.50758182 255.58019414 242.30366399 269.54060652 264.16919869\n", + " 272.51291813 283.48890394 310.40469131 337.19108152 362.22738833], predicted sequence: MDTLKQLAAAAFNDLAFRLVSAAFLKVLRDAFLGFPDKGRAAKIYYVAPDVVFCCFCGPGGVQAENGADPPYRWANGMPSPPLVLASKSDELTTELKLL\n", + "================================================\n", + "foldproteins: True\n", + "Writing FASTA file: /content/working_results/4_test_individual_cases/fasta_in_100.fasta\n", + "Now run OmegaFold.... on device=cuda:0\n", + "INFO:root:Loading weights from /root/.cache/omegafold_ckpt/model.pt\n", + "INFO:root:Constructing OmegaFold\n", + "INFO:root:Reading /content/working_results/4_test_individual_cases/fasta_in_100.fasta\n", + "INFO:root:Predicting 1th chain in /content/working_results/4_test_individual_cases/fasta_in_100.fasta\n", + "INFO:root:99 residues in this chain.\n", + "INFO:root:Finished prediction in 10.67 seconds.\n", + "INFO:root:Saving prediction to /content/working_results/4_test_individual_cases/temp_100.pdb\n", + "INFO:root:Saved\n", + "INFO:root:Done!\n", + "\n", + "Done OmegaFold\n", + "Resulting PDB file...: /content/working_results/4_test_individual_cases/temp_100.pdb\n", + "Properly named PDB file produced: /content/working_results/4_test_individual_cases/DN_1_CondS_No_0_Val_1.0_epo_100_step_100.pdb\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "application/3dmoljs_load.v0": "
\n

You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension:
\n jupyter labextension install jupyterlab_3dmol

\n
\n", + "text/html": [ + "
\n", + "

You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension:
\n", + " jupyter labextension install jupyterlab_3dmol

\n", + "
\n", + "" + ] + }, + "metadata": {} + } + ], + "source": [ + "#@title ### Example:\n", + "\n", + "#@markdown Infer for given unfolding force vecter\n", + "\n", + "\n", + "Sample_for_Num_inputs = 2 #@param {type:\"slider\", min:1, max:8, step:1}\n", + "\n", + "\n", + "\n", + "\n", + "#\n", + "if CKeys['Working_Mode']==2:\n", + " if TestKeys['Sample_On_DeNovo']:\n", + " #\n", + " print(\"Run sampling on De Novo inputs set...\")\n", + " #\n", + " # de novo test\n", + " if CKeys['Problem_ID']==2 or CKeys['Problem_ID']==6 \\\n", + " or CKeys['Problem_ID']==11:\n", + " print('Loading back a common de novo tests: ')\n", + " import pickle\n", + " pk_save_de_novo_list = this_working_path+'0_dataprocess_MD/ForTest_LE_128_From_F1_f5.pt'\n", + "\n", + " with open(pk_save_de_novo_list, 'rb') as handle:\n", + " de_novo_test_condition_list = pickle.load(handle)\n", + "\n", + " de_novo_test_condition_list = de_novo_test_condition_list[:8]\n", + " print(\"Get de novo tests #: \", len(de_novo_test_condition_list))\n", + " # de_novo_test_condition_list = [\n", + " # # =====================================\n", + " # # sacle max:\n", + "\n", + " # UtilityPack.interpolate_and_resample_ForcPath(\n", + " # y0=protein_df['sample_FORCE_data'][pick_id_0]*1.0,\n", + " # seq_len1=protein_df['seq_len'][pick_id_0],\n", + " # )['y1'], # max_forc x 1\n", + "\n", + " # UtilityPack.interpolate_and_resample_ForcPath(\n", + " # y0=protein_df['sample_FORCE_data'][pick_id_0]*0.66,\n", + " # seq_len1=60,\n", + " # )['y1'], # max_forc x 0.66\n", + "\n", + " # UtilityPack.interpolate_and_resample_ForcPath(\n", + " # y0=protein_df['sample_FORCE_data'][pick_id_0]*0.33,\n", + " # seq_len1=60,\n", + " # )['y1'], # max_forc x 0.33\n", + "\n", + " # UtilityPack.interpolate_and_resample_ForcPath(\n", + " # y0=protein_df['sample_FORCE_data'][pick_id_0]*1.50,\n", + " # seq_len1=60,\n", + " # )['y1'], # max_forc x 1.5\n", + " # # =====================================\n", + " # # scale mid peak: 2\n", + "\n", + " # UtilityPack.interpolate_and_resample_ForcPath(\n", + " # y0=protein_df['sample_FORCE_data'][2]*1.0,\n", + " # seq_len1=protein_df['seq_len'][2],\n", + " # )['y1'], # peak_mid x 1\n", + "\n", + " # UtilityPack.interpolate_and_resample_ForcPath(\n", + " # y0=protein_df['sample_FORCE_data'][2]*0.66,\n", + " # seq_len1=60,\n", + " # )['y1'], # max_forc x 0.66\n", + "\n", + " # UtilityPack.interpolate_and_resample_ForcPath(\n", + " # y0=protein_df['sample_FORCE_data'][2]*0.33,\n", + " # seq_len1=60,\n", + " # )['y1'], # max_forc x 0.33\n", + "\n", + " # UtilityPack.interpolate_and_resample_ForcPath(\n", + " # y0=protein_df['sample_FORCE_data'][2]*1.50,\n", + " # seq_len1=60,\n", + " # )['y1'], # max_forc x 1.50\n", + " # # ======================================\n", + " # # mix two: max and min\n", + "\n", + " # UtilityPack.mix_two_ForcPath(\n", + " # y0=protein_df['sample_FORCE_data'][pick_id_0]*1.,\n", + " # y1=protein_df['sample_FORCE_data'][pick_id_1]*0.,\n", + " # seq_len2=60,\n", + " # )['y2'], # max x 1 + min x 0\n", + "\n", + " # UtilityPack.mix_two_ForcPath(\n", + " # y0=protein_df['sample_FORCE_data'][pick_id_0]*2./3.,\n", + " # y1=protein_df['sample_FORCE_data'][pick_id_1]*1./3.,\n", + " # seq_len2=60,\n", + " # )['y2'], # max x 2/3 + min x 1/3\n", + "\n", + " # UtilityPack.mix_two_ForcPath(\n", + " # y0=protein_df['sample_FORCE_data'][pick_id_0]*1./2.,\n", + " # y1=protein_df['sample_FORCE_data'][pick_id_1]*1./2.,\n", + " # seq_len2=60,\n", + " # )['y2'], # max x 1/2 + min x 1/2\n", + "\n", + " # UtilityPack.mix_two_ForcPath(\n", + " # y0=protein_df['sample_FORCE_data'][pick_id_0]*1./3.,\n", + " # y1=protein_df['sample_FORCE_data'][pick_id_1]*2./3.,\n", + " # seq_len2=60,\n", + " # )['y2'], # max x 1/3 + min x 2/3\n", + "\n", + " # UtilityPack.mix_two_ForcPath(\n", + " # y0=protein_df['sample_FORCE_data'][pick_id_0]*0.,\n", + " # y1=protein_df['sample_FORCE_data'][pick_id_1]*1.,\n", + " # seq_len2=60,\n", + " # )['y2'], # max x 0. + min x 1.\n", + " # # =======================================\n", + " # # mix another two: middle peak 2 + slope 174\n", + "\n", + " # UtilityPack.mix_two_ForcPath(\n", + " # y0=protein_df['sample_FORCE_data'][2]*1.,\n", + " # y1=protein_df['sample_FORCE_data'][174]*0.,\n", + " # seq_len2=60,\n", + " # )['y2'], # max x 1 + min x 0\n", + "\n", + " # UtilityPack.mix_two_ForcPath(\n", + " # y0=protein_df['sample_FORCE_data'][2]*2./3.,\n", + " # y1=protein_df['sample_FORCE_data'][174]*1./3.,\n", + " # seq_len2=60,\n", + " # )['y2'], # max x 2/3 + min x 1/3\n", + "\n", + " # UtilityPack.mix_two_ForcPath(\n", + " # y0=protein_df['sample_FORCE_data'][2]*1./2.,\n", + " # y1=protein_df['sample_FORCE_data'][174]*1./2.,\n", + " # seq_len2=60,\n", + " # )['y2'], # max x 1/2 + min x 1/2\n", + "\n", + " # UtilityPack.mix_two_ForcPath(\n", + " # y0=protein_df['sample_FORCE_data'][2]*1./3.,\n", + " # y1=protein_df['sample_FORCE_data'][174]*2./3.,\n", + " # seq_len2=60,\n", + " # )['y2'], # max x 1/3 + min x 2/3\n", + "\n", + " # UtilityPack.mix_two_ForcPath(\n", + " # y0=protein_df['sample_FORCE_data'][2]*0.,\n", + " # y1=protein_df['sample_FORCE_data'][174]*1.,\n", + " # seq_len2=60,\n", + " # )['y2'], # max x 0. + min x 1.\n", + "\n", + " # ]\n", + "\n", + " elif CKeys['Problem_ID']==3:\n", + " de_novo_test_condition_list = [\n", + " [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1],\n", + " [0, 0.7, 0.07, 0.1, 0.01, 0.02, 0.01, 0.11],\n", + " ]\n", + " elif CKeys['Problem_ID']==4:\n", + " # normalized (Fmax,Toughness)\n", + " de_novo_test_condition_list = [\n", + " [0.8, 0.8],\n", + " [0.8, 0.2],\n", + " ]\n", + "\n", + " elif CKeys['Problem_ID']==5:\n", + " de_novo_test_condition_list = [\n", + " ['~~~HHHHHHHHHHHHHHH~~'],\n", + " ['~~EEESSTTS~SEEEEEEEEE~SBS~EEEEEE~~'],\n", + " ]\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "if CKeys['Working_Mode']==2:\n", + " #\n", + " if TestKeys['Sample_On_DeNovo']:\n", + "\n", + "\n", + " if CKeys['Problem_ID']==2:\n", + " TrainerPack.sample_sequence_omegafold_ModelB (\n", + " working_model_B,\n", + " x_data=NewInput_List,\n", + " flag=last_epoch, # flag=\"DeNovo\", # ,\n", + " cond_scales=1.,\n", + " foldproteins=True, # foldproteins,\n", + " # ++++++++++\n", + " ynormfac=DataKeys['ynormfac'],\n", + " train_unet_number=1, # train_unet_number,\n", + " tokenizer_X=tokenizer_X,\n", + " Xnormfac=DataKeys['Xnormfac'],\n", + " max_length=DataKeys['max_AA_seq_len'], # max_length,\n", + " prefix=PKeys['prefix'], # prefix,\n", + " tokenizer_y=tokenizer_y,\n", + " # ++\n", + " CKeys=CKeys,\n", + " sample_dir=TestKeys['test_dir'], # sample_dir,\n", + " steps=last_step,\n", + " e=last_epoch,\n", + " IF_showfig= True, # CKeys['SlientRun']!=1,\n", + " )\n", + "\n", + " elif CKeys['Problem_ID']==3:\n", + " TrainerPack.sample_sequence_omegafold_ModelA (\n", + " # # ----------------------------------------------\n", + " # model,\n", + " # X=[[0, 0.7, 0.07, 0.1, 0.01, 0.02, 0.01, 0.11]],\n", + " # foldproteins=foldproteins,\n", + " # flag=steps,cond_scales=1.,\n", + " # ++++++++++++++++++++++++++++++++++++++++++++++\n", + " working_model,\n", + " X=test_condition_list, # [[0.92, 0., 0.04, 0.04, 0., 0., 0., 0., ]], # from text conditioning X\n", + " flag=last_epoch, # e+start_ep, # steps, # 0,\n", + " cond_scales=1., # cond_scales, # 1.,\n", + " foldproteins=True, # False,\n", + " X_string=None, # from text conditioning X_string\n", + " x_data=None, # from image conditioning x_data\n", + " skip_steps=0,\n", + " inpaint_images=None, # in formation Y data\n", + " inpaint_masks = None,\n", + " inpaint_resample_times = None,\n", + " init_images = None,\n", + " num_cycle=16, # for omegafolding\n", + " calc_error=True, # False, # for check on folded results, not used for every case\n", + " # ++++++++++++++++++++++++++\n", + " # tokenizers\n", + " tokenizer_X_forImageCondi=None, # for x_data\n", + " Xnormfac_forImageCondi=1.,\n", + " tokenizer_X_forTextCondi=None, # for X if NEEDED only\n", + " Xnormfac_forTextCondi=DataKeys['Xnormfac'], # 1.,\n", + " tokenizer_y=tokenizer_y, # None, # for output Y\n", + " ynormfac=DataKeys['ynormfac'], # ynormfac,\n", + " # length\n", + " train_unet_number=1,\n", + " max_length_Y=DataKeys['max_AA_seq_len'], # max_length_Y, # for Y, X_forImageCondi\n", + " max_text_len=DataKeys['max_text_len'], # max_text_len_X, # for X_forTextCondi\n", + " # other info\n", + " steps=last_step, # steps, # None,\n", + " e=last_epoch, # e, # None,\n", + " sample_dir=TestKeys['test_dir'], # sample_dir, # None,\n", + " prefix=PKeys['prefix'], # prefix, # None,\n", + " IF_showfig= True, # CKeys['SlientRun']!=1, # True,\n", + " CKeys=CKeys,\n", + " # TBA to Model B\n", + " normalize_X_cond_to_one=False,\n", + " )\n", + " #\n", + " elif CKeys['Problem_ID']==4:\n", + " TrainerPack.sample_sequence_omegafold_ModelA (\n", + " # # ----------------------------------------------\n", + " # model,\n", + " # X=[[0, 0.7, 0.07, 0.1, 0.01, 0.02, 0.01, 0.11]],\n", + " # foldproteins=foldproteins,\n", + " # flag=steps,cond_scales=1.,\n", + " # ++++++++++++++++++++++++++++++++++++++++++++++\n", + " working_model,\n", + " X=test_condition_list, # [[0.92, 0., 0.04, 0.04, 0., 0., 0., 0., ]], # from text conditioning X\n", + " flag=last_epoch, # e+start_ep, # steps, # 0,\n", + " cond_scales=1., # cond_scales, # 1.,\n", + " foldproteins=True, # False,\n", + " X_string=None, # from text conditioning X_string\n", + " x_data=None, # from image conditioning x_data\n", + " skip_steps=0,\n", + " inpaint_images=None, # in formation Y data\n", + " inpaint_masks = None,\n", + " inpaint_resample_times = None,\n", + " init_images = None,\n", + " num_cycle=16, # for omegafolding\n", + " # only for ModelA-SecStr:ProblemID:4\n", + " calc_error=False, # True, # False, # for check on folded results, not used for every case\n", + " # ++++++++++++++++++++++++++\n", + " # tokenizers\n", + " tokenizer_X_forImageCondi=None, # for x_data\n", + " Xnormfac_forImageCondi=1.,\n", + " tokenizer_X_forTextCondi=None, # for X if NEEDED only\n", + " Xnormfac_forTextCondi=DataKeys['Xnormfac'], # 1.,\n", + " tokenizer_y=tokenizer_y, # None, # for output Y\n", + " ynormfac=DataKeys['ynormfac'], # ynormfac,\n", + " # length\n", + " train_unet_number=1,\n", + " max_length_Y=DataKeys['max_AA_seq_len'], # max_length_Y, # for Y, X_forImageCondi\n", + " max_text_len=DataKeys['max_text_len'], # max_text_len_X, # for X_forTextCondi\n", + " # other info\n", + " steps=last_step, # steps, # None,\n", + " e=last_epoch, # e, # None,\n", + " sample_dir=TestKeys['test_dir'], # sample_dir, # None,\n", + " prefix=PKeys['prefix'], # prefix, # None,\n", + " IF_showfig= True, # CKeys['SlientRun']!=1, # True,\n", + " CKeys=CKeys,\n", + " # TBA to Model B\n", + " normalize_X_cond_to_one=False,\n", + " )\n", + " # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n", + " # Model B + SecStr\n", + " # <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n", + " elif CKeys['Problem_ID']==5:\n", + " DeNovoSam_pdbs, DeNovoSam_fasta = \\\n", + " TrainerPack.sample_sequence_omegafold_pLM_ModelB (\n", + " working_model,\n", + " x_data=NewInput_List,\n", + " flag=last_epoch, # flag=\"DeNovo\", # ,\n", + " cond_scales=1.,\n", + " foldproteins=True, # foldproteins,\n", + " # ++++++++++\n", + " ynormfac=DataKeys['ynormfac'],\n", + " train_unet_number=1, # train_unet_number,\n", + " tokenizer_X=tokenizer_X,\n", + " Xnormfac=DataKeys['Xnormfac'],\n", + " max_length=DataKeys['max_AA_seq_len'], # max_length,\n", + " prefix=PKeys['prefix'], # prefix,\n", + " tokenizer_y=tokenizer_y,\n", + " # ++\n", + " CKeys=CKeys,\n", + " sample_dir=TestKeys['test_dir'], # sample_dir,\n", + " steps=last_step,\n", + " e=last_epoch,\n", + " IF_showfig= True, # CKeys['SlientRun']!=1,\n", + " # ++\n", + " pLM_Model=pLM_Model,\n", + " pLM_Model_Name=pLM_Model_Name,\n", + " image_channels=DataKeys['image_channels'],\n", + " pLM_alphabet=esm_alphabet,\n", + " )\n", + " #\n", + " elif CKeys['Problem_ID']==6:\n", + " DeNovoSam_pdbs, DeNovoSam_fasta = \\\n", + " TrainerPack.sample_sequence_omegafold_pLM_ModelB_For_ForcPath (\n", + " working_model,\n", + " x_data=de_novo_test_condition_list[:2],\n", + " flag=last_epoch, # flag=\"DeNovo\", # ,\n", + " cond_scales=[1., 2.],\n", + " foldproteins=True, # foldproteins,\n", + " # ++++++++++\n", + " ynormfac=DataKeys['ynormfac'],\n", + " train_unet_number=1, # train_unet_number,\n", + " tokenizer_X=tokenizer_X,\n", + " Xnormfac=DataKeys['Xnormfac'],\n", + " max_length=DataKeys['max_AA_seq_len'], # max_length,\n", + " prefix=PKeys['prefix'], # prefix,\n", + " tokenizer_y=tokenizer_y,\n", + " # ++\n", + " CKeys=CKeys,\n", + " sample_dir=TestKeys['test_dir'], # sample_dir,\n", + " steps=last_step,\n", + " e=last_epoch,\n", + " IF_showfig= True, # CKeys['SlientRun']!=1,\n", + " # ++\n", + " pLM_Model=pLM_Model,\n", + " pLM_Model_Name=pLM_Model_Name,\n", + " image_channels=DataKeys['image_channels'],\n", + " pLM_alphabet=esm_alphabet,\n", + " )\n", + "\n", + " # DeNovoSam_pdbs, DeNovoSam_fasta = \\\n", + " # TrainerPack.sample_sequence_omegafold_pLM_ModelB (\n", + " # working_model,\n", + " # x_data=NewInput_List,\n", + " # flag=last_epoch, # flag=\"DeNovo\", # ,\n", + " # cond_scales=1.,\n", + " # foldproteins=True, # foldproteins,\n", + " # # ++++++++++\n", + " # ynormfac=DataKeys['ynormfac'],\n", + " # train_unet_number=1, # train_unet_number,\n", + " # tokenizer_X=tokenizer_X,\n", + " # Xnormfac=DataKeys['Xnormfac'],\n", + " # max_length=DataKeys['max_AA_seq_len'], # max_length,\n", + " # prefix=PKeys['prefix'], # prefix,\n", + " # tokenizer_y=tokenizer_y,\n", + " # # ++\n", + " # CKeys=CKeys,\n", + " # sample_dir=TestKeys['test_dir'], # sample_dir,\n", + " # steps=last_step,\n", + " # e=last_epoch,\n", + " # IF_showfig= True, # CKeys['SlientRun']!=1,\n", + " # # ++\n", + " # pLM_Model=pLM_Model,\n", + " # pLM_Model_Name=pLM_Model_Name,\n", + " # image_channels=DataKeys['image_channels'],\n", + " # pLM_alphabet=esm_alphabet,\n", + " # )\n", + " #\n", + " elif CKeys['Problem_ID']==7:\n", + " DeNovoSam_pdbs, fasta_file_list=\\\n", + " TrainerPack.sample_sequence_omegafold_pLM_ModelA (\n", + " working_model,\n", + " X=NewInput_List, # test_condition_list, # [[0.92, 0., 0.04, 0.04, 0., 0., 0., 0., ]], # from text conditioning X\n", + " flag=last_epoch, # e+start_ep, # steps, # 0,\n", + " cond_scales=1.,\n", + " foldproteins=True, # False,\n", + " X_string=None, # from text conditioning X_string\n", + " x_data=None, # from image conditioning x_data\n", + " skip_steps=0,\n", + " inpaint_images=None, # in formation Y data\n", + " inpaint_masks = None,\n", + " inpaint_resample_times = None,\n", + " init_images = None,\n", + " num_cycle=16, # for omegafolding\n", + " calc_error=True, # False, # for check on folded results, not used for every case\n", + " # ++++++++++++++++++++++++++\n", + " # tokenizers\n", + " tokenizer_X_forImageCondi=None, # for x_data\n", + " Xnormfac_forImageCondi=1.,\n", + " tokenizer_X_forTextCondi=None, # for X if NEEDED only\n", + " Xnormfac_forTextCondi=1.,\n", + " tokenizer_y=tokenizer_y, # None, # for output Y\n", + " ynormfac=DataKeys['ynormfac'], # ynormfac,\n", + " # length\n", + " train_unet_number=1,\n", + " max_length_Y=DataKeys['max_AA_seq_len'], # max_length_Y, # for Y, X_forImageCondi\n", + " max_text_len=DataKeys['max_text_len'], # max_text_len_X, # for X_forTextCondi\n", + " # other info\n", + " steps=last_step, # None,\n", + " e=last_epoch, # None,\n", + " sample_dir=TestKeys['test_dir'], # None,\n", + " prefix=PKeys['prefix'], # None,\n", + " IF_showfig= True, # CKeys['SlientRun']!=1, # True,\n", + " CKeys=CKeys,\n", + " # TBA to Model B\n", + " normalize_X_cond_to_one=False,\n", + " # ++ for pLM\n", + " pLM_Model=pLM_Model,\n", + " pLM_Model_Name=pLM_Model_Name,\n", + " image_channels=DataKeys['image_channels'], # image_channels,\n", + " pLM_alphabet=esm_alphabet,\n", + " )\n", + "\n", + " elif CKeys['Problem_ID']==8:\n", + " DeNovoSam_pdbs, fasta_file_list=\\\n", + " TrainerPack.sample_sequence_omegafold_pLM_ModelA (\n", + " working_model,\n", + " X=NewInput_List, # test_condition_list, # [[0.92, 0., 0.04, 0.04, 0., 0., 0., 0., ]], # from text conditioning X\n", + " flag=last_epoch, # e+start_ep, # steps, # 0,\n", + " cond_scales=1.,\n", + " foldproteins=True, # False,\n", + " X_string=None, # from text conditioning X_string\n", + " x_data=None, # from image conditioning x_data\n", + " skip_steps=0,\n", + " inpaint_images=None, # in formation Y data\n", + " inpaint_masks = None,\n", + " inpaint_resample_times = None,\n", + " init_images = None,\n", + " num_cycle=16, # for omegafolding\n", + " calc_error=True, # False, # for check on folded results, not used for every case\n", + " # ++++++++++++++++++++++++++\n", + " # tokenizers\n", + " tokenizer_X_forImageCondi=None, # for x_data\n", + " Xnormfac_forImageCondi=1.,\n", + " tokenizer_X_forTextCondi=None, # for X if NEEDED only\n", + " Xnormfac_forTextCondi=1.,\n", + " tokenizer_y=tokenizer_y, # None, # for output Y\n", + " ynormfac=DataKeys['ynormfac'], # ynormfac,\n", + " # length\n", + " train_unet_number=1,\n", + " max_length_Y=DataKeys['max_AA_seq_len'], # max_length_Y, # for Y, X_forImageCondi\n", + " max_text_len=DataKeys['max_text_len'], # max_text_len_X, # for X_forTextCondi\n", + " # other info\n", + " steps=last_step, # None,\n", + " e=last_epoch, # None,\n", + " sample_dir=TestKeys['test_dir'], # None,\n", + " prefix=PKeys['prefix'], # None,\n", + " IF_showfig= CKeys['SlientRun']!=1, # True,\n", + " CKeys=CKeys,\n", + " # TBA to Model B\n", + " normalize_X_cond_to_one=False,\n", + " # ++ for pLM\n", + " pLM_Model=pLM_Model,\n", + " pLM_Model_Name=pLM_Model_Name,\n", + " image_channels=DataKeys['image_channels'], # image_channels,\n", + " pLM_alphabet=esm_alphabet,\n", + " )\n", + "\n", + " elif CKeys['Problem_ID']==11:\n", + " # plot the input\n", + " print(\"On the inputs:\")\n", + " fig = plt.figure(figsize=(24,16),dpi=200)\n", + " fig, ax0 = plt.subplots()\n", + " for ii in range(Sample_for_Num_inputs):\n", + " ax0.plot(\n", + " de_novo_test_condition_list[ii],\n", + " label='Input_'+str(ii+0)+'_to_be_inferred'\n", + " )\n", + "\n", + " plt.legend()\n", + " plt.xlabel('Normalized pulling gap')\n", + " plt.ylabel('Pulling force (kcal/(mol*Å))')\n", + " plt.show()\n", + " plt.close()\n", + " # conduct inferring\n", + " print(\"Now, make design based on the inputs...\")\n", + " print(\"\\n\\n\")\n", + " DeNovoSam_pdbs, DeNovoSam_fasta = \\\n", + " TrainerPack.sample_sequence_omegafold_pLM_ModelB_For_ForcPath (\n", + " working_model,\n", + " x_data=de_novo_test_condition_list[:Sample_for_Num_inputs], # [:2],\n", + " flag=100, #last_epoch, # flag=\"DeNovo\", # ,\n", + " cond_scales=[1.],\n", + " foldproteins=True, # foldproteins,\n", + " # ++++++++++\n", + " ynormfac=DataKeys['ynormfac'],\n", + " train_unet_number=1, # train_unet_number,\n", + " tokenizer_X=tokenizer_X,\n", + " Xnormfac=DataKeys['Xnormfac'],\n", + " max_length=DataKeys['max_AA_seq_len'], # max_length,\n", + " prefix=PKeys['prefix'], # prefix,\n", + " tokenizer_y=tokenizer_y,\n", + " # ++\n", + " CKeys=CKeys,\n", + " sample_dir=TestKeys['test_dir'], # sample_dir,\n", + " steps=100, # last_step,\n", + " e=100, # last_epoch,\n", + " IF_showfig= True, # CKeys['SlientRun']!=1,\n", + " # ++\n", + " pLM_Model=pLM_Model,\n", + " pLM_Model_Name=pLM_Model_Name,\n", + " image_channels=DataKeys['image_channels'],\n", + " pLM_alphabet=esm_alphabet,\n", + " )\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e0KlqgH44W3W", + "metadata": { + "id": "e0KlqgH44W3W" + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "tuGOEsVx4W6U", + "metadata": { + "id": "tuGOEsVx4W6U" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "V100", + "machine_shape": "hm", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.16" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "31b76154485744478e55cc7d644fe746": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "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_b91214c632844be79784f736e0286379", + "IPY_MODEL_8377bd6062634dc0a7c3859dd5f8ecb7", + "IPY_MODEL_d07fe0b5583f42ceb02fc5868b438d53" + ], + "layout": "IPY_MODEL_48308612cb754c008454fc38ed384b52" + } + }, + "b91214c632844be79784f736e0286379": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_598765bb9ff44e27a9859be5cf509085", + "placeholder": "​", + "style": "IPY_MODEL_26b86f56191e445d83e8be32a97b9d9c", + "value": "Fetching 15 files: 100%" + } + }, + "8377bd6062634dc0a7c3859dd5f8ecb7": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "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_06254cd412fe49a593e403e623443936", + "max": 15, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ec3d80bb4e5d4b5ea97b5fc8501bfd88", + "value": 15 + } + }, + "d07fe0b5583f42ceb02fc5868b438d53": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_606c8307e71f4aeb93c01efa7ec6ef1b", + "placeholder": "​", + "style": "IPY_MODEL_2e7e5ae5dc7d4fd5ad8c3454c8d1a8b3", + "value": " 15/15 [00:25<00:00, 5.08s/it]" + } + }, + "48308612cb754c008454fc38ed384b52": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "598765bb9ff44e27a9859be5cf509085": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "26b86f56191e445d83e8be32a97b9d9c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "06254cd412fe49a593e403e623443936": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "ec3d80bb4e5d4b5ea97b5fc8501bfd88": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "606c8307e71f4aeb93c01efa7ec6ef1b": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "2e7e5ae5dc7d4fd5ad8c3454c8d1a8b3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "6e4183f68b8e45578b723d6c22b2131d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "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_43f46bf3a1ac4cbbb7d02fab05409616", + "IPY_MODEL_1bef507bea924964b98351fa40e5ef5c", + "IPY_MODEL_521ca46708fd475e9aab84315a5134e9" + ], + "layout": "IPY_MODEL_e503a7ba732849c794876e389608b87e" + } + }, + "43f46bf3a1ac4cbbb7d02fab05409616": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_2f131547fd8749dc844d305da218b2b7", + "placeholder": "​", + "style": "IPY_MODEL_2e193afeaeff448499bee67461232fae", + "value": "Model_files/ForTest_LE_128_From_F1_f5.pk: 100%" + } + }, + "1bef507bea924964b98351fa40e5ef5c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "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_163874d15eb64530ba139f51665897bb", + "max": 167976, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_71d597ffa540452d9a5862670ad80ed9", + "value": 167976 + } + }, + "521ca46708fd475e9aab84315a5134e9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_35506943c1a347209ff1afaf201f8e78", + "placeholder": "​", + "style": "IPY_MODEL_23e18ee6795c4a5dae9de8ea2a0189ee", + "value": " 168k/168k [00:00<00:00, 1.02MB/s]" + } + }, + "e503a7ba732849c794876e389608b87e": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "2f131547fd8749dc844d305da218b2b7": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "2e193afeaeff448499bee67461232fae": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "163874d15eb64530ba139f51665897bb": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "71d597ffa540452d9a5862670ad80ed9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "35506943c1a347209ff1afaf201f8e78": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "23e18ee6795c4a5dae9de8ea2a0189ee": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "4f97f85d76e04a909c6109d3763538f3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "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_c35fa7d83d2a4025a17cd968d12f3513", + "IPY_MODEL_9fd13b4d8dfc43919826d8fc8946f852", + "IPY_MODEL_cf5f5f84fc034480b444c25e9a739306" + ], + "layout": "IPY_MODEL_40076a4b6dee46c7beddd312ec0bcc68" + } + }, + "c35fa7d83d2a4025a17cd968d12f3513": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_91602dce765e45f7826320373adb610e", + "placeholder": "​", + "style": "IPY_MODEL_8daa30bf214b4b93a32ef3cd7a579a35", + "value": ".gitattributes: 100%" + } + }, + "9fd13b4d8dfc43919826d8fc8946f852": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "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_2fb57a342a4f4530a0bbd0075cccde6b", + "max": 1632, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_92139a49b52d4c16b0a7cbed62959945", + "value": 1632 + } + }, + "cf5f5f84fc034480b444c25e9a739306": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_2467748981b34d589df1ad9afe26ec44", + "placeholder": "​", + "style": "IPY_MODEL_bf93ac54779a4effbac95750b47a2ec4", + "value": " 1.63k/1.63k [00:00<00:00, 118kB/s]" + } + }, + "40076a4b6dee46c7beddd312ec0bcc68": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "91602dce765e45f7826320373adb610e": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "8daa30bf214b4b93a32ef3cd7a579a35": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "2fb57a342a4f4530a0bbd0075cccde6b": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "92139a49b52d4c16b0a7cbed62959945": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "2467748981b34d589df1ad9afe26ec44": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "bf93ac54779a4effbac95750b47a2ec4": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "8946e09a59d54d28824feeda129ec3df": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "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_ee3181f0224f4c9b8ffc4a7b811d43c2", + "IPY_MODEL_8a01cc48caa84fb88da774ff60ba1161", + "IPY_MODEL_aa98db21228942c09f738a58d6b9eb45" + ], + "layout": "IPY_MODEL_600f5cdae4c44f918497e6740f097938" + } + }, + "ee3181f0224f4c9b8ffc4a7b811d43c2": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_18536412cf204a7bb3cdba37c1080a10", + "placeholder": "​", + "style": "IPY_MODEL_54475c76a710459a81757cd2375dc55e", + "value": "PD_pLMProbXDiff/PostMDPack.py: 100%" + } + }, + "8a01cc48caa84fb88da774ff60ba1161": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "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_a98db38ebf3b4f5f8ac47b0654df59ef", + "max": 11119, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_5ce184dd537349b4b495f18b71f32c70", + "value": 11119 + } + }, + "aa98db21228942c09f738a58d6b9eb45": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_8436eac1684b4af5bfb0bdc570a8c07a", + "placeholder": "​", + "style": "IPY_MODEL_62e753d05ad040e2811c5cbbc99368cb", + "value": " 11.1k/11.1k [00:00<00:00, 846kB/s]" + } + }, + "600f5cdae4c44f918497e6740f097938": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "18536412cf204a7bb3cdba37c1080a10": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "54475c76a710459a81757cd2375dc55e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "a98db38ebf3b4f5f8ac47b0654df59ef": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "5ce184dd537349b4b495f18b71f32c70": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "8436eac1684b4af5bfb0bdc570a8c07a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "62e753d05ad040e2811c5cbbc99368cb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "8db11ff9354e4eb4978f169e0d106702": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "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_3b0c6ac29eb64c7dad5234df2988609c", + "IPY_MODEL_7e3024f69bb8421796ee4f13160e771b", + "IPY_MODEL_c078477b2f5b49aba535a767c63ca960" + ], + "layout": "IPY_MODEL_2615f70d9cee402c9fe7d87de3b03751" + } + }, + "3b0c6ac29eb64c7dad5234df2988609c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_492b0898427d4236af7aa14db39d7095", + "placeholder": "​", + "style": "IPY_MODEL_a10b5601aa1945b58d9d00ebf6aaef4c", + "value": "data_pack.pickle: 100%" + } + }, + "7e3024f69bb8421796ee4f13160e771b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "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_0120d6ece55d49da8d7edfebc0ce2428", + "max": 10544628, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_81961147224f490ebcfbbf051f80cfe9", + "value": 10544628 + } + }, + "c078477b2f5b49aba535a767c63ca960": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_2a454d13caf349ddac93bef841abbe95", + "placeholder": "​", + "style": "IPY_MODEL_5899063f548c4288bfbb4c536282dd25", + "value": " 10.5M/10.5M [00:00<00:00, 45.3MB/s]" + } + }, + "2615f70d9cee402c9fe7d87de3b03751": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "492b0898427d4236af7aa14db39d7095": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "a10b5601aa1945b58d9d00ebf6aaef4c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "0120d6ece55d49da8d7edfebc0ce2428": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "81961147224f490ebcfbbf051f80cfe9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "2a454d13caf349ddac93bef841abbe95": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "5899063f548c4288bfbb4c536282dd25": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "d95e3a7b0dbf4bab8952653661411002": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "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_e57efe4c1b6040f0a4ebed57af9fafa7", + "IPY_MODEL_f01c3a76902e4baab545d4fa55cb406f", + "IPY_MODEL_d3922d8e2b5b4844ac13b352f1458b90" + ], + "layout": "IPY_MODEL_df10d508ddac4bf08649cf141dc820af" + } + }, + "e57efe4c1b6040f0a4ebed57af9fafa7": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_f7cd2e14af8b4b239bc4c9720ae4a126", + "placeholder": "​", + "style": "IPY_MODEL_7dee81aa62bb47759537e70156d92a2b", + "value": "model_pack.pickle: 100%" + } + }, + "f01c3a76902e4baab545d4fa55cb406f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "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_f1c9b154b1a14066ac49f7379f73b276", + "max": 1739, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9101600fd21747d782743fd719fdbc6e", + "value": 1739 + } + }, + "d3922d8e2b5b4844ac13b352f1458b90": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_2e2590bd707e4df08f04ba40f5078cef", + "placeholder": "​", + "style": "IPY_MODEL_9526e4debf5c42fe984edc3697969bda", + "value": " 1.74k/1.74k [00:00<00:00, 65.7kB/s]" + } + }, + "df10d508ddac4bf08649cf141dc820af": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "f7cd2e14af8b4b239bc4c9720ae4a126": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "7dee81aa62bb47759537e70156d92a2b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "f1c9b154b1a14066ac49f7379f73b276": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "9101600fd21747d782743fd719fdbc6e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "2e2590bd707e4df08f04ba40f5078cef": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "9526e4debf5c42fe984edc3697969bda": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "1e0dcf3e6ec642a0a7a262ae3ba64423": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "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_93e094d9622e43a2b978d1705444787f", + "IPY_MODEL_fda184abe87441bf842e0d223fc88f69", + "IPY_MODEL_62e5273f963d4de1a8cfd3778de85a38" + ], + "layout": "IPY_MODEL_e0468bbf403442cf8bec34717d1ab2f0" + } + }, + "93e094d9622e43a2b978d1705444787f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_6dd7fbe246f1486897145702d920a8f2", + "placeholder": "​", + "style": "IPY_MODEL_9cdf097f914f40f38ca05c5333140b1d", + "value": "trainer_save-model_pLDM.pt: 100%" + } + }, + "fda184abe87441bf842e0d223fc88f69": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "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_e6d7b24d4f3c45df96fb2ad1b8362182", + "max": 4139545643, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_437bf4b0c3e549e2a51b93e71757355e", + "value": 4139545643 + } + }, + "62e5273f963d4de1a8cfd3778de85a38": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_7ba49690b88f4c329a669b736c2390cb", + "placeholder": "​", + "style": "IPY_MODEL_9153427390874b4e8dc30aad8f7534d4", + "value": " 4.14G/4.14G [00:23<00:00, 175MB/s]" + } + }, + "e0468bbf403442cf8bec34717d1ab2f0": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "6dd7fbe246f1486897145702d920a8f2": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "9cdf097f914f40f38ca05c5333140b1d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "e6d7b24d4f3c45df96fb2ad1b8362182": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "437bf4b0c3e549e2a51b93e71757355e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "7ba49690b88f4c329a669b736c2390cb": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "9153427390874b4e8dc30aad8f7534d4": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "d8642b7617904b1e99d60058fe591bfb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "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_a0b2f6e911554904b8416daf41014877", + "IPY_MODEL_8ee0c34fb57f402e8ad281ee9d9103b6", + "IPY_MODEL_3988f07b8cf242819c200344b7533bb1" + ], + "layout": "IPY_MODEL_4d276cde65474631b9005d9c37bcc632" + } + }, + "a0b2f6e911554904b8416daf41014877": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_197b8fc5756c4172a019a1ba781a6948", + "placeholder": "​", + "style": "IPY_MODEL_bdf81bd0021c4d53afc6421bbd7550ca", + "value": "mkdssp: 100%" + } + }, + "8ee0c34fb57f402e8ad281ee9d9103b6": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "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_9fd3ad949ed64b3eba606bdd9b4a0bb9", + "max": 13398231, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0150e43dd40a4829a6f7cd4b2aefffb1", + "value": 13398231 + } + }, + "3988f07b8cf242819c200344b7533bb1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_fe61e35062bf4fdcb25b995cc1e94606", + "placeholder": "​", + "style": "IPY_MODEL_e6cc826c0c8149cd889897e77b73583b", + "value": " 13.4M/13.4M [00:00<00:00, 48.1MB/s]" + } + }, + "4d276cde65474631b9005d9c37bcc632": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "197b8fc5756c4172a019a1ba781a6948": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "bdf81bd0021c4d53afc6421bbd7550ca": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "9fd3ad949ed64b3eba606bdd9b4a0bb9": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "0150e43dd40a4829a6f7cd4b2aefffb1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "fe61e35062bf4fdcb25b995cc1e94606": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "e6cc826c0c8149cd889897e77b73583b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "466a8c0cf92b48aaa9456edcf189359c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "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_ac6eba851ffa4bef8677d9a88728b6ec", + "IPY_MODEL_b43290c3564143e6a0db29a28f483aa9", + "IPY_MODEL_97457f41555f4285af7f78364ff00391" + ], + "layout": "IPY_MODEL_7b5ec9d323ba4903aed101fc33c1fe53" + } + }, + "ac6eba851ffa4bef8677d9a88728b6ec": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_0007b124c85943c6a7931b60f0314dec", + "placeholder": "​", + "style": "IPY_MODEL_a0f47e73b7014204b56d34addddb2b47", + "value": "PD_pLMProbXDiff/TrainerPack.py: 100%" + } + }, + "b43290c3564143e6a0db29a28f483aa9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "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_b1ffbe10a3564cca8c61982d7e3691b3", + "max": 342934, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_74f2b10f9ae74a4a8f1e02224bf7efd0", + "value": 342934 + } + }, + "97457f41555f4285af7f78364ff00391": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_d240547dda464fa6a711d8402de97909", + "placeholder": "​", + "style": "IPY_MODEL_f922730449664c92b0c97abdd7b04869", + "value": " 343k/343k [00:00<00:00, 1.44MB/s]" + } + }, + "7b5ec9d323ba4903aed101fc33c1fe53": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "0007b124c85943c6a7931b60f0314dec": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "a0f47e73b7014204b56d34addddb2b47": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "b1ffbe10a3564cca8c61982d7e3691b3": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "74f2b10f9ae74a4a8f1e02224bf7efd0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "d240547dda464fa6a711d8402de97909": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "f922730449664c92b0c97abdd7b04869": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "8e735dd693834425b12c75b630516e65": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "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_a7a0dfe5759e4dbbb038819ee31d5aff", + "IPY_MODEL_71490e2421114d76ad7d8ba44019032e", + "IPY_MODEL_5125a5c2bf784074a0ca831ee537b33d" + ], + "layout": "IPY_MODEL_67934b32d2d648ddbf942687e6b9cf95" + } + }, + "a7a0dfe5759e4dbbb038819ee31d5aff": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_24a3e1ba23a94e548d59a7a4e0f16d47", + "placeholder": "​", + "style": "IPY_MODEL_dd0bd71ecd544d83b130cfc02ede8fd4", + "value": "PD_pLMProbXDiff/UtilityPack.py: 100%" + } + }, + "71490e2421114d76ad7d8ba44019032e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "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_05b54d61fdad4c43a2751a5432aa08bf", + "max": 21647, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ea6aed1be6004b91a8c69ddae0b603f1", + "value": 21647 + } + }, + "5125a5c2bf784074a0ca831ee537b33d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_8a1c75d147e246bab942911f8c0d5fe0", + "placeholder": "​", + "style": "IPY_MODEL_f892e01a42b548518415c3b01bf21e05", + "value": " 21.6k/21.6k [00:00<00:00, 695kB/s]" + } + }, + "67934b32d2d648ddbf942687e6b9cf95": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "24a3e1ba23a94e548d59a7a4e0f16d47": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "dd0bd71ecd544d83b130cfc02ede8fd4": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "05b54d61fdad4c43a2751a5432aa08bf": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "ea6aed1be6004b91a8c69ddae0b603f1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "8a1c75d147e246bab942911f8c0d5fe0": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "f892e01a42b548518415c3b01bf21e05": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "01196943b43543b8b37813fc08ae9b59": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "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_b091a4ae8b484cdda67d42c5fe35a2cc", + "IPY_MODEL_6b6949dd2c884140a5ced117399c3209", + "IPY_MODEL_eb0bfb3302dc44b494c4294898878095" + ], + "layout": "IPY_MODEL_ae16b52ea1b84fbaad9f86724b47bf8c" + } + }, + "b091a4ae8b484cdda67d42c5fe35a2cc": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_ef11f302c91647ce82e4afb5ba74977d", + "placeholder": "​", + "style": "IPY_MODEL_fdfc9d83f68b410f841b174f9137f775", + "value": "(…)ab/pLDM_inferring_standalong_colab.ipynb: 100%" + } + }, + "6b6949dd2c884140a5ced117399c3209": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "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_4730bbfff16b4f2b969684b455eb2659", + "max": 700958, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7eb7484118fb494c8435d949bb737a5e", + "value": 700958 + } + }, + "eb0bfb3302dc44b494c4294898878095": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_2940f69ec013406fa021767648a867d0", + "placeholder": "​", + "style": "IPY_MODEL_2a4f553da4554c688a3eff6900d2da49", + "value": " 701k/701k [00:00<00:00, 2.15MB/s]" + } + }, + "ae16b52ea1b84fbaad9f86724b47bf8c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "ef11f302c91647ce82e4afb5ba74977d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "fdfc9d83f68b410f841b174f9137f775": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "4730bbfff16b4f2b969684b455eb2659": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "7eb7484118fb494c8435d949bb737a5e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "2940f69ec013406fa021767648a867d0": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "2a4f553da4554c688a3eff6900d2da49": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "61243205ef664695a875b702ec4ad477": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "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_6104bb58b9bf4842832547c15d245062", + "IPY_MODEL_7381e16abd80451faa4a57df4efe9a1a", + "IPY_MODEL_56d80ab8e3254e2ba1bb2cb8092bc6e5" + ], + "layout": "IPY_MODEL_c509a31ec4db4c1a9c9fa239370218f2" + } + }, + "6104bb58b9bf4842832547c15d245062": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_8adf0e212a624ea281ebda67d5ff2902", + "placeholder": "​", + "style": "IPY_MODEL_7ffb49f4f4e14478b6e58777be7ec5b0", + "value": "Figure1.png: 100%" + } + }, + "7381e16abd80451faa4a57df4efe9a1a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "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_0bb4f6caa0bf47adba5e46f1ab21af4a", + "max": 3262850, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_60c4707a19c84c94862e1ead0e8e35d4", + "value": 3262850 + } + }, + "56d80ab8e3254e2ba1bb2cb8092bc6e5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_92f10e1dec9546ba91656be340657ad9", + "placeholder": "​", + "style": "IPY_MODEL_7f66067f4b084d06a801d30c9480eb3f", + "value": " 3.26M/3.26M [00:00<00:00, 47.8MB/s]" + } + }, + "c509a31ec4db4c1a9c9fa239370218f2": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "8adf0e212a624ea281ebda67d5ff2902": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "7ffb49f4f4e14478b6e58777be7ec5b0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "0bb4f6caa0bf47adba5e46f1ab21af4a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "60c4707a19c84c94862e1ead0e8e35d4": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "92f10e1dec9546ba91656be340657ad9": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "7f66067f4b084d06a801d30c9480eb3f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "127bb6cf455a464b8c310cd3e7391ee7": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "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_d08703bfa18a4d8c82384a62d3880303", + "IPY_MODEL_ad79567db4f743bbaf034ec93f9ea459", + "IPY_MODEL_5a53e60a144949c38521c936530236e5" + ], + "layout": "IPY_MODEL_203a295b78c341578b205addca9ca4a2" + } + }, + "d08703bfa18a4d8c82384a62d3880303": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_27e14517288547e2bd61585b4a81b265", + "placeholder": "​", + "style": "IPY_MODEL_3945a03afc6d4437a58626bf84bccbf1", + "value": "Model_files/list_model_files.txt: " + } + }, + "ad79567db4f743bbaf034ec93f9ea459": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "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_9bb2bee68f41432b931e8959e5e7ff9c", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b8fe9f9fdd0e4fbabf5092801ffde0a2", + "value": 0 + } + }, + "5a53e60a144949c38521c936530236e5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_ab7c4d5f1c244d51875a82f307ca4ac9", + "placeholder": "​", + "style": "IPY_MODEL_8aecf07975164da1983684e9b1ba5b8d", + "value": " 0.00/0.00 [00:00<?, ?B/s]" + } + }, + "203a295b78c341578b205addca9ca4a2": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "27e14517288547e2bd61585b4a81b265": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "3945a03afc6d4437a58626bf84bccbf1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "9bb2bee68f41432b931e8959e5e7ff9c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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": "20px" + } + }, + "b8fe9f9fdd0e4fbabf5092801ffde0a2": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "ab7c4d5f1c244d51875a82f307ca4ac9": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "8aecf07975164da1983684e9b1ba5b8d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "c715294e3af94ed6a84d41257fb1ebd8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "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_0806463940cc494f8cc3e4403719c088", + "IPY_MODEL_a4a2c89211bb4c30aaee0b422f21dfcd", + "IPY_MODEL_129bcf067c34499181ef68e5ec6983da" + ], + "layout": "IPY_MODEL_f940ca44ab86458686ca8590ffb86f8a" + } + }, + "0806463940cc494f8cc3e4403719c088": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_f6166cb5676144e59b24978a0c35fd81", + "placeholder": "​", + "style": "IPY_MODEL_4034623f97704b0bbae1ecbac8a14feb", + "value": "PD_pLMProbXDiff/ModelPack.py: 100%" + } + }, + "a4a2c89211bb4c30aaee0b422f21dfcd": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "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_ebc72a111b884a0da552c416852735c6", + "max": 217718, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a822016ea3984b02b953ee3f611de747", + "value": 217718 + } + }, + "129bcf067c34499181ef68e5ec6983da": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_2f7f8af1674f456f942e4df889a10658", + "placeholder": "​", + "style": "IPY_MODEL_c982dd7718474ccebfc3e9e072b0f7db", + "value": " 218k/218k [00:00<00:00, 1.34MB/s]" + } + }, + "f940ca44ab86458686ca8590ffb86f8a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "f6166cb5676144e59b24978a0c35fd81": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "4034623f97704b0bbae1ecbac8a14feb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "ebc72a111b884a0da552c416852735c6": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "a822016ea3984b02b953ee3f611de747": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "2f7f8af1674f456f942e4df889a10658": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "c982dd7718474ccebfc3e9e072b0f7db": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "a5ad8853f0c84acd9329dbe66400677c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "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_a708d6a943764823827b3991911b4545", + "IPY_MODEL_6b582ec702eb4985b72ed33446c970c3", + "IPY_MODEL_9aba2669e8314d22ad68e2f85fed53dc" + ], + "layout": "IPY_MODEL_527f9b7bd3ff4601a5464cf9f4c44b97" + } + }, + "a708d6a943764823827b3991911b4545": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_d79a2eab006b4023affbd3f3e50d2767", + "placeholder": "​", + "style": "IPY_MODEL_4a9d3d8b88114ae1af3d61c5e5944b15", + "value": "PD_pLMProbXDiff/DataSetPack.py: 100%" + } + }, + "6b582ec702eb4985b72ed33446c970c3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "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_276909a5fe684555a13332f95e6fae36", + "max": 113484, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d22334856a5a401b98ebdea3b6929ce5", + "value": 113484 + } + }, + "9aba2669e8314d22ad68e2f85fed53dc": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_34325901472d40489ec31f9de1dc31de", + "placeholder": "​", + "style": "IPY_MODEL_c126d9cad639494983454e01464d76ac", + "value": " 113k/113k [00:00<00:00, 1.33MB/s]" + } + }, + "527f9b7bd3ff4601a5464cf9f4c44b97": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "d79a2eab006b4023affbd3f3e50d2767": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "4a9d3d8b88114ae1af3d61c5e5944b15": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "276909a5fe684555a13332f95e6fae36": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "d22334856a5a401b98ebdea3b6929ce5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "34325901472d40489ec31f9de1dc31de": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "c126d9cad639494983454e01464d76ac": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "a1f099b6335f4edc8ac09a07f61c5ca1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "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_fb86e9e80a3d401ebeba7e61ada616d6", + "IPY_MODEL_473a285c607148ecafafc189a4fd99be", + "IPY_MODEL_db081c2664ef4a5fbf91ad04469a55cf" + ], + "layout": "IPY_MODEL_e60886445f0540acb562398ef347048b" + } + }, + "fb86e9e80a3d401ebeba7e61ada616d6": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_f937c6638513488b8bf7c82193e1bf5f", + "placeholder": "​", + "style": "IPY_MODEL_16b511679b034f4d91427cbcd334e8fa", + "value": "README.md: 100%" + } + }, + "473a285c607148ecafafc189a4fd99be": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "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_972949e856ee48539cdabbb4dadc87a4", + "max": 2033, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_75907672dabf4f828973a67ca8776c3a", + "value": 2033 + } + }, + "db081c2664ef4a5fbf91ad04469a55cf": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_763ce29864c74c3a86881a9ef9e00893", + "placeholder": "​", + "style": "IPY_MODEL_6f2a94f1a67e494f8c41903e7d8c7046", + "value": " 2.03k/2.03k [00:00<00:00, 158kB/s]" + } + }, + "e60886445f0540acb562398ef347048b": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "f937c6638513488b8bf7c82193e1bf5f": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "16b511679b034f4d91427cbcd334e8fa": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "972949e856ee48539cdabbb4dadc87a4": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "75907672dabf4f828973a67ca8776c3a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "763ce29864c74c3a86881a9ef9e00893": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "6f2a94f1a67e494f8c41903e7d8c7046": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "2c23bccd6b9c43a3828967e6fdddc903": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "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_9678cabbc21540ffb6ea08a605afba75", + "IPY_MODEL_b2362c4e5fc64b00a391c09d1e4e7a4c", + "IPY_MODEL_aa4867c32bb5452d8135a8351dcccff0" + ], + "layout": "IPY_MODEL_adb1469b44c940faae1e411eb1a99b9d" + } + }, + "9678cabbc21540ffb6ea08a605afba75": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_eb0bd6944fdd48c1a4ac19c27ca22348", + "placeholder": "​", + "style": "IPY_MODEL_d7afed151ec1424e9ca260cf7258f492", + "value": "" + } + }, + "b2362c4e5fc64b00a391c09d1e4e7a4c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "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_df6da5864eb44630b814e295e4a52359", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8e93adc8f51243b7b509838efd0c7278", + "value": 0 + } + }, + "aa4867c32bb5452d8135a8351dcccff0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_b626ec9d0a9643848a6ec1410d0fc1a9", + "placeholder": "​", + "style": "IPY_MODEL_3ae4a95a3568416ab38a0276ce51ab2e", + "value": " 0/0 [00:00<?, ?it/s]" + } + }, + "adb1469b44c940faae1e411eb1a99b9d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "eb0bd6944fdd48c1a4ac19c27ca22348": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "d7afed151ec1424e9ca260cf7258f492": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "df6da5864eb44630b814e295e4a52359": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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": "20px" + } + }, + "8e93adc8f51243b7b509838efd0c7278": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "b626ec9d0a9643848a6ec1410d0fc1a9": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "3ae4a95a3568416ab38a0276ce51ab2e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "b1063f05bded44b8b81e65644d9327dc": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "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_c10b34b4e90541cea5a992a5ce08622c", + "IPY_MODEL_d5729cd0f5564f6f89379dd8c19342b3", + "IPY_MODEL_006aacca0dc5492d85e564ed103a67a6" + ], + "layout": "IPY_MODEL_2c49f4aecad54c0b94f02ba53c421d72" + } + }, + "c10b34b4e90541cea5a992a5ce08622c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_0cc7b34cd24541259ee452668e509ee1", + "placeholder": "​", + "style": "IPY_MODEL_58357213c566489f9bd273bb2fc379e3", + "value": "" + } + }, + "d5729cd0f5564f6f89379dd8c19342b3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "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": "danger", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7649557e264b4652a66bcbbe80c733d7", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f313949895864eceaa883a24f4d5cd50", + "value": 0 + } + }, + "006aacca0dc5492d85e564ed103a67a6": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_142c2882d70f4e4fb3b745f7c6aea4a6", + "placeholder": "​", + "style": "IPY_MODEL_09529ba57fa14da08fbdf0fdacf8d57a", + "value": " 0/? [00:09<?, ?it/s]" + } + }, + "2c49f4aecad54c0b94f02ba53c421d72": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "0cc7b34cd24541259ee452668e509ee1": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "58357213c566489f9bd273bb2fc379e3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "7649557e264b4652a66bcbbe80c733d7": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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": "20px" + } + }, + "f313949895864eceaa883a24f4d5cd50": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "142c2882d70f4e4fb3b745f7c6aea4a6": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "09529ba57fa14da08fbdf0fdacf8d57a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "9941323d83d14c028518d172e6c78026": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "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_f221312d70d5426780dc5080ddf99eba", + "IPY_MODEL_1916469bb9d34c268917db8a32b83fad", + "IPY_MODEL_801cef6fec3743aa845672e01ed2b08e" + ], + "layout": "IPY_MODEL_09328d4991e84294a37839f3bcdb165d" + } + }, + "f221312d70d5426780dc5080ddf99eba": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_d82139981f4843ae82b492ea29640ba6", + "placeholder": "​", + "style": "IPY_MODEL_cc54c1bec4984a57b71d6911006885f5", + "value": "sampling time step: 100%" + } + }, + "1916469bb9d34c268917db8a32b83fad": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "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_64268382856c4859bc45e5127fa0fbaa", + "max": 96, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fb999a48d3794d7a8e874b6c94be4aef", + "value": 96 + } + }, + "801cef6fec3743aa845672e01ed2b08e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_dd37e86c809446da9d3f50f4aa08197b", + "placeholder": "​", + "style": "IPY_MODEL_d996d94ee547475188640f6a8de9f867", + "value": " 96/96 [00:08<00:00, 12.09it/s]" + } + }, + "09328d4991e84294a37839f3bcdb165d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "d82139981f4843ae82b492ea29640ba6": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "cc54c1bec4984a57b71d6911006885f5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "64268382856c4859bc45e5127fa0fbaa": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "fb999a48d3794d7a8e874b6c94be4aef": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "dd37e86c809446da9d3f50f4aa08197b": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_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 + } + }, + "d996d94ee547475188640f6a8de9f867": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file