From 296a6e5d395474a15ce8a77b9a3bc0a90ade69b5 Mon Sep 17 00:00:00 2001 From: Jonathan Taylor Date: Sun, 30 Jul 2023 12:05:22 -0400 Subject: [PATCH] reran and saved Ch10 --- Ch10-deeplearning-lab.ipynb | 5505 ++++++++++++++++++++++++++++++++++- 1 file changed, 5411 insertions(+), 94 deletions(-) diff --git a/Ch10-deeplearning-lab.ipynb b/Ch10-deeplearning-lab.ipynb index 80ee043..6bbb5b4 100644 --- a/Ch10-deeplearning-lab.ipynb +++ b/Ch10-deeplearning-lab.ipynb @@ -755,7 +755,7 @@ "hit_dm = SimpleDataModule(hit_train,\n", " hit_test,\n", " batch_size=32,\n", - " num_workers=4, #min(4, max_num_workers),\n", + " num_workers=min(4, max_num_workers),\n", " validation=hit_test)" ] }, @@ -876,7 +876,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6c2c00e38c8b43738decbcb6cdf52412", + "model_id": "e781e48e320e4989b7ec1705466dc871", "version_major": 2, "version_minor": 0 }, @@ -1548,7 +1548,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "", + "model_id": "68fd72c197344c01ac3b50a7f606c1a1", "version_major": 2, "version_minor": 0 }, @@ -1562,7 +1562,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "", + "model_id": "c831c14303644d8e8aafd12a3d20e377", "version_major": 2, "version_minor": 0 }, @@ -1576,7 +1576,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "", + "model_id": "22b02297078049e4bc0a5a57e5ed59f1", "version_major": 2, "version_minor": 0 }, @@ -1628,7 +1628,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1582c1cd9afb492193ff7bcdfc2fdd9a", + "model_id": "3ac7a2bfb65c4b7ca01694d5b4e845d5", "version_major": 2, "version_minor": 0 }, @@ -2181,7 +2181,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6c811e724d3e4e6ca982bcf8c5e68832", + "model_id": "0448d9e7c0f34b5ba04c7b2740db1f57", "version_major": 2, "version_minor": 0 }, @@ -2706,7 +2706,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8b1fc2e19cda40d78484bfaade82ec6c", + "model_id": "c87fe4617b354d73956e5c34642e9182", "version_major": 2, "version_minor": 0 }, @@ -2824,7 +2824,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "16fde280b03241409e1b3b889d4c5a74", + "model_id": "f563e01864944a15936f03ff994b5e0e", "version_major": 2, "version_minor": 0 }, @@ -3287,7 +3287,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f8c6ccecd9364129871ae290735d57e4", + "model_id": "a47437bd6bb7423cbf8d5bd71ece6380", "version_major": 2, "version_minor": 0 }, @@ -3719,7 +3719,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 58, "id": "1ea339ff", "metadata": {}, "outputs": [ @@ -3760,7 +3760,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "b8c54fa3440349639c4b6abbeca76230", + "model_id": "860fbc1e8afa4bc4a5ab3f8570fa147c", "version_major": 2, "version_minor": 0 }, @@ -3868,6 +3868,335 @@ }, "metadata": {}, "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=30` reached.\n" + ] } ], "source": [ @@ -3896,10 +4225,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 59, "id": "0a9068d9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "log_path = cifar_logger.experiment.metrics_file_path\n", "cifar_results = pd.read_csv(log_path)\n", @@ -3923,10 +4263,47 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 60, "id": "e71eff9b", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d5e5870b3b85460f8ce3f275fb8e3bcd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Testing: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", + "Runningstage.testing metric DataLoader 0\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", + " test_accuracy 0.42969998717308044\n", + " test_loss 2.4235761165618896\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n" + ] + }, + { + "data": { + "text/plain": [ + "[{'test_loss': 2.4235761165618896, 'test_accuracy': 0.42969998717308044}]" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "cifar_trainer.test(cifar_module,\n", " datamodule=cifar_dm)" @@ -3954,10 +4331,508 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 61, "id": "58eae430", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "-------------------------------------------\n", + "0 | model | CIFARModel | 964 K \n", + "1 | loss | CrossEntropyLoss | 0 \n", + "-------------------------------------------\n", + "964 K Trainable params\n", + "0 Non-trainable params\n", + "964 K Total params\n", + "3.858 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b15916ee481a4843ba3862bff3f29847", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_311/lib/python3.11/site-packages/torchmetrics/functional/classification/accuracy.py:77: UserWarning: MPS: no support for int64 reduction ops, casting it to int32 (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/native/mps/operations/ReduceOps.mm:144.)\n", + " tp = tp.sum(dim=0 if multidim_average == \"global\" else 1)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=30` reached.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ad90899ca665421899dfe6a0c50b4b7a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Testing: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "try:\n", " for name, metric in cifar_module.metrics.items():\n", @@ -4006,10 +4881,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 62, "id": "638a1c8c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_311/lib/python3.11/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/plain": [ + "torch.Size([6, 3, 224, 224])" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "resize = Resize((232,232))\n", "crop = CenterCrop(224)\n", @@ -4032,10 +4926,209 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 63, "id": "7776ed1e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "===================================================================================================================\n", + "Layer (type:depth-idx) Input Shape Output Shape Param #\n", + "===================================================================================================================\n", + "ResNet [6, 3, 224, 224] [6, 1000] --\n", + "├─Conv2d: 1-1 [6, 3, 224, 224] [6, 64, 112, 112] 9,408\n", + "├─BatchNorm2d: 1-2 [6, 64, 112, 112] [6, 64, 112, 112] 128\n", + "├─ReLU: 1-3 [6, 64, 112, 112] [6, 64, 112, 112] --\n", + "├─MaxPool2d: 1-4 [6, 64, 112, 112] [6, 64, 56, 56] --\n", + "├─Sequential: 1-5 [6, 64, 56, 56] [6, 256, 56, 56] --\n", + "│ └─Bottleneck: 2-1 [6, 64, 56, 56] [6, 256, 56, 56] --\n", + "│ │ └─Conv2d: 3-1 [6, 64, 56, 56] [6, 64, 56, 56] 4,096\n", + "│ │ └─BatchNorm2d: 3-2 [6, 64, 56, 56] [6, 64, 56, 56] 128\n", + "│ │ └─ReLU: 3-3 [6, 64, 56, 56] [6, 64, 56, 56] --\n", + "│ │ └─Conv2d: 3-4 [6, 64, 56, 56] [6, 64, 56, 56] 36,864\n", + "│ │ └─BatchNorm2d: 3-5 [6, 64, 56, 56] [6, 64, 56, 56] 128\n", + "│ │ └─ReLU: 3-6 [6, 64, 56, 56] [6, 64, 56, 56] --\n", + "│ │ └─Conv2d: 3-7 [6, 64, 56, 56] [6, 256, 56, 56] 16,384\n", + "│ │ └─BatchNorm2d: 3-8 [6, 256, 56, 56] [6, 256, 56, 56] 512\n", + "│ │ └─Sequential: 3-9 [6, 64, 56, 56] [6, 256, 56, 56] 16,896\n", + "│ │ └─ReLU: 3-10 [6, 256, 56, 56] [6, 256, 56, 56] --\n", + "│ └─Bottleneck: 2-2 [6, 256, 56, 56] [6, 256, 56, 56] --\n", + "│ │ └─Conv2d: 3-11 [6, 256, 56, 56] [6, 64, 56, 56] 16,384\n", + "│ │ └─BatchNorm2d: 3-12 [6, 64, 56, 56] [6, 64, 56, 56] 128\n", + "│ │ └─ReLU: 3-13 [6, 64, 56, 56] [6, 64, 56, 56] --\n", + "│ │ └─Conv2d: 3-14 [6, 64, 56, 56] [6, 64, 56, 56] 36,864\n", + "│ │ └─BatchNorm2d: 3-15 [6, 64, 56, 56] [6, 64, 56, 56] 128\n", + "│ │ └─ReLU: 3-16 [6, 64, 56, 56] [6, 64, 56, 56] --\n", + "│ │ └─Conv2d: 3-17 [6, 64, 56, 56] [6, 256, 56, 56] 16,384\n", + "│ │ └─BatchNorm2d: 3-18 [6, 256, 56, 56] [6, 256, 56, 56] 512\n", + "│ │ └─ReLU: 3-19 [6, 256, 56, 56] [6, 256, 56, 56] --\n", + "│ └─Bottleneck: 2-3 [6, 256, 56, 56] [6, 256, 56, 56] --\n", + "│ │ └─Conv2d: 3-20 [6, 256, 56, 56] [6, 64, 56, 56] 16,384\n", + "│ │ └─BatchNorm2d: 3-21 [6, 64, 56, 56] [6, 64, 56, 56] 128\n", + "│ │ └─ReLU: 3-22 [6, 64, 56, 56] [6, 64, 56, 56] --\n", + "│ │ └─Conv2d: 3-23 [6, 64, 56, 56] [6, 64, 56, 56] 36,864\n", + "│ │ └─BatchNorm2d: 3-24 [6, 64, 56, 56] [6, 64, 56, 56] 128\n", + "│ │ └─ReLU: 3-25 [6, 64, 56, 56] [6, 64, 56, 56] --\n", + "│ │ └─Conv2d: 3-26 [6, 64, 56, 56] [6, 256, 56, 56] 16,384\n", + "│ │ └─BatchNorm2d: 3-27 [6, 256, 56, 56] [6, 256, 56, 56] 512\n", + "│ │ └─ReLU: 3-28 [6, 256, 56, 56] [6, 256, 56, 56] --\n", + "├─Sequential: 1-6 [6, 256, 56, 56] [6, 512, 28, 28] --\n", + "│ └─Bottleneck: 2-4 [6, 256, 56, 56] [6, 512, 28, 28] --\n", + "│ │ └─Conv2d: 3-29 [6, 256, 56, 56] [6, 128, 56, 56] 32,768\n", + "│ │ └─BatchNorm2d: 3-30 [6, 128, 56, 56] [6, 128, 56, 56] 256\n", + "│ │ └─ReLU: 3-31 [6, 128, 56, 56] [6, 128, 56, 56] --\n", + "│ │ └─Conv2d: 3-32 [6, 128, 56, 56] [6, 128, 28, 28] 147,456\n", + "│ │ └─BatchNorm2d: 3-33 [6, 128, 28, 28] [6, 128, 28, 28] 256\n", + "│ │ └─ReLU: 3-34 [6, 128, 28, 28] [6, 128, 28, 28] --\n", + "│ │ └─Conv2d: 3-35 [6, 128, 28, 28] [6, 512, 28, 28] 65,536\n", + "│ │ └─BatchNorm2d: 3-36 [6, 512, 28, 28] [6, 512, 28, 28] 1,024\n", + "│ │ └─Sequential: 3-37 [6, 256, 56, 56] [6, 512, 28, 28] 132,096\n", + "│ │ └─ReLU: 3-38 [6, 512, 28, 28] [6, 512, 28, 28] --\n", + "│ └─Bottleneck: 2-5 [6, 512, 28, 28] [6, 512, 28, 28] --\n", + "│ │ └─Conv2d: 3-39 [6, 512, 28, 28] [6, 128, 28, 28] 65,536\n", + "│ │ └─BatchNorm2d: 3-40 [6, 128, 28, 28] [6, 128, 28, 28] 256\n", + "│ │ └─ReLU: 3-41 [6, 128, 28, 28] [6, 128, 28, 28] --\n", + "│ │ └─Conv2d: 3-42 [6, 128, 28, 28] [6, 128, 28, 28] 147,456\n", + "│ │ └─BatchNorm2d: 3-43 [6, 128, 28, 28] [6, 128, 28, 28] 256\n", + "│ │ └─ReLU: 3-44 [6, 128, 28, 28] [6, 128, 28, 28] --\n", + "│ │ └─Conv2d: 3-45 [6, 128, 28, 28] [6, 512, 28, 28] 65,536\n", + "│ │ └─BatchNorm2d: 3-46 [6, 512, 28, 28] [6, 512, 28, 28] 1,024\n", + "│ │ └─ReLU: 3-47 [6, 512, 28, 28] [6, 512, 28, 28] --\n", + "│ └─Bottleneck: 2-6 [6, 512, 28, 28] [6, 512, 28, 28] --\n", + "│ │ └─Conv2d: 3-48 [6, 512, 28, 28] [6, 128, 28, 28] 65,536\n", + "│ │ └─BatchNorm2d: 3-49 [6, 128, 28, 28] [6, 128, 28, 28] 256\n", + "│ │ └─ReLU: 3-50 [6, 128, 28, 28] [6, 128, 28, 28] --\n", + "│ │ └─Conv2d: 3-51 [6, 128, 28, 28] [6, 128, 28, 28] 147,456\n", + "│ │ └─BatchNorm2d: 3-52 [6, 128, 28, 28] [6, 128, 28, 28] 256\n", + "│ │ └─ReLU: 3-53 [6, 128, 28, 28] [6, 128, 28, 28] --\n", + "│ │ └─Conv2d: 3-54 [6, 128, 28, 28] [6, 512, 28, 28] 65,536\n", + "│ │ └─BatchNorm2d: 3-55 [6, 512, 28, 28] [6, 512, 28, 28] 1,024\n", + "│ │ └─ReLU: 3-56 [6, 512, 28, 28] [6, 512, 28, 28] --\n", + "│ └─Bottleneck: 2-7 [6, 512, 28, 28] [6, 512, 28, 28] --\n", + "│ │ └─Conv2d: 3-57 [6, 512, 28, 28] [6, 128, 28, 28] 65,536\n", + "│ │ └─BatchNorm2d: 3-58 [6, 128, 28, 28] [6, 128, 28, 28] 256\n", + "│ │ └─ReLU: 3-59 [6, 128, 28, 28] [6, 128, 28, 28] --\n", + "│ │ └─Conv2d: 3-60 [6, 128, 28, 28] [6, 128, 28, 28] 147,456\n", + "│ │ └─BatchNorm2d: 3-61 [6, 128, 28, 28] [6, 128, 28, 28] 256\n", + "│ │ └─ReLU: 3-62 [6, 128, 28, 28] [6, 128, 28, 28] --\n", + "│ │ └─Conv2d: 3-63 [6, 128, 28, 28] [6, 512, 28, 28] 65,536\n", + "│ │ └─BatchNorm2d: 3-64 [6, 512, 28, 28] [6, 512, 28, 28] 1,024\n", + "│ │ └─ReLU: 3-65 [6, 512, 28, 28] [6, 512, 28, 28] --\n", + "├─Sequential: 1-7 [6, 512, 28, 28] [6, 1024, 14, 14] --\n", + "│ └─Bottleneck: 2-8 [6, 512, 28, 28] [6, 1024, 14, 14] --\n", + "│ │ └─Conv2d: 3-66 [6, 512, 28, 28] [6, 256, 28, 28] 131,072\n", + "│ │ └─BatchNorm2d: 3-67 [6, 256, 28, 28] [6, 256, 28, 28] 512\n", + "│ │ └─ReLU: 3-68 [6, 256, 28, 28] [6, 256, 28, 28] --\n", + "│ │ └─Conv2d: 3-69 [6, 256, 28, 28] [6, 256, 14, 14] 589,824\n", + "│ │ └─BatchNorm2d: 3-70 [6, 256, 14, 14] [6, 256, 14, 14] 512\n", + "│ │ └─ReLU: 3-71 [6, 256, 14, 14] [6, 256, 14, 14] --\n", + "│ │ └─Conv2d: 3-72 [6, 256, 14, 14] [6, 1024, 14, 14] 262,144\n", + "│ │ └─BatchNorm2d: 3-73 [6, 1024, 14, 14] [6, 1024, 14, 14] 2,048\n", + "│ │ └─Sequential: 3-74 [6, 512, 28, 28] [6, 1024, 14, 14] 526,336\n", + "│ │ └─ReLU: 3-75 [6, 1024, 14, 14] [6, 1024, 14, 14] --\n", + "│ └─Bottleneck: 2-9 [6, 1024, 14, 14] [6, 1024, 14, 14] --\n", + "│ │ └─Conv2d: 3-76 [6, 1024, 14, 14] [6, 256, 14, 14] 262,144\n", + "│ │ └─BatchNorm2d: 3-77 [6, 256, 14, 14] [6, 256, 14, 14] 512\n", + "│ │ └─ReLU: 3-78 [6, 256, 14, 14] [6, 256, 14, 14] --\n", + "│ │ └─Conv2d: 3-79 [6, 256, 14, 14] [6, 256, 14, 14] 589,824\n", + "│ │ └─BatchNorm2d: 3-80 [6, 256, 14, 14] [6, 256, 14, 14] 512\n", + "│ │ └─ReLU: 3-81 [6, 256, 14, 14] [6, 256, 14, 14] --\n", + "│ │ └─Conv2d: 3-82 [6, 256, 14, 14] [6, 1024, 14, 14] 262,144\n", + "│ │ └─BatchNorm2d: 3-83 [6, 1024, 14, 14] [6, 1024, 14, 14] 2,048\n", + "│ │ └─ReLU: 3-84 [6, 1024, 14, 14] [6, 1024, 14, 14] --\n", + "│ └─Bottleneck: 2-10 [6, 1024, 14, 14] [6, 1024, 14, 14] --\n", + "│ │ └─Conv2d: 3-85 [6, 1024, 14, 14] [6, 256, 14, 14] 262,144\n", + "│ │ └─BatchNorm2d: 3-86 [6, 256, 14, 14] [6, 256, 14, 14] 512\n", + "│ │ └─ReLU: 3-87 [6, 256, 14, 14] [6, 256, 14, 14] --\n", + "│ │ └─Conv2d: 3-88 [6, 256, 14, 14] [6, 256, 14, 14] 589,824\n", + "│ │ └─BatchNorm2d: 3-89 [6, 256, 14, 14] [6, 256, 14, 14] 512\n", + "│ │ └─ReLU: 3-90 [6, 256, 14, 14] [6, 256, 14, 14] --\n", + "│ │ └─Conv2d: 3-91 [6, 256, 14, 14] [6, 1024, 14, 14] 262,144\n", + "│ │ └─BatchNorm2d: 3-92 [6, 1024, 14, 14] [6, 1024, 14, 14] 2,048\n", + "│ │ └─ReLU: 3-93 [6, 1024, 14, 14] [6, 1024, 14, 14] --\n", + "│ └─Bottleneck: 2-11 [6, 1024, 14, 14] [6, 1024, 14, 14] --\n", + "│ │ └─Conv2d: 3-94 [6, 1024, 14, 14] [6, 256, 14, 14] 262,144\n", + "│ │ └─BatchNorm2d: 3-95 [6, 256, 14, 14] [6, 256, 14, 14] 512\n", + "│ │ └─ReLU: 3-96 [6, 256, 14, 14] [6, 256, 14, 14] --\n", + "│ │ └─Conv2d: 3-97 [6, 256, 14, 14] [6, 256, 14, 14] 589,824\n", + "│ │ └─BatchNorm2d: 3-98 [6, 256, 14, 14] [6, 256, 14, 14] 512\n", + "│ │ └─ReLU: 3-99 [6, 256, 14, 14] [6, 256, 14, 14] --\n", + "│ │ └─Conv2d: 3-100 [6, 256, 14, 14] [6, 1024, 14, 14] 262,144\n", + "│ │ └─BatchNorm2d: 3-101 [6, 1024, 14, 14] [6, 1024, 14, 14] 2,048\n", + "│ │ └─ReLU: 3-102 [6, 1024, 14, 14] [6, 1024, 14, 14] --\n", + "│ └─Bottleneck: 2-12 [6, 1024, 14, 14] [6, 1024, 14, 14] --\n", + "│ │ └─Conv2d: 3-103 [6, 1024, 14, 14] [6, 256, 14, 14] 262,144\n", + "│ │ └─BatchNorm2d: 3-104 [6, 256, 14, 14] [6, 256, 14, 14] 512\n", + "│ │ └─ReLU: 3-105 [6, 256, 14, 14] [6, 256, 14, 14] --\n", + "│ │ └─Conv2d: 3-106 [6, 256, 14, 14] [6, 256, 14, 14] 589,824\n", + "│ │ └─BatchNorm2d: 3-107 [6, 256, 14, 14] [6, 256, 14, 14] 512\n", + "│ │ └─ReLU: 3-108 [6, 256, 14, 14] [6, 256, 14, 14] --\n", + "│ │ └─Conv2d: 3-109 [6, 256, 14, 14] [6, 1024, 14, 14] 262,144\n", + "│ │ └─BatchNorm2d: 3-110 [6, 1024, 14, 14] [6, 1024, 14, 14] 2,048\n", + "│ │ └─ReLU: 3-111 [6, 1024, 14, 14] [6, 1024, 14, 14] --\n", + "│ └─Bottleneck: 2-13 [6, 1024, 14, 14] [6, 1024, 14, 14] --\n", + "│ │ └─Conv2d: 3-112 [6, 1024, 14, 14] [6, 256, 14, 14] 262,144\n", + "│ │ └─BatchNorm2d: 3-113 [6, 256, 14, 14] [6, 256, 14, 14] 512\n", + "│ │ └─ReLU: 3-114 [6, 256, 14, 14] [6, 256, 14, 14] --\n", + "│ │ └─Conv2d: 3-115 [6, 256, 14, 14] [6, 256, 14, 14] 589,824\n", + "│ │ └─BatchNorm2d: 3-116 [6, 256, 14, 14] [6, 256, 14, 14] 512\n", + "│ │ └─ReLU: 3-117 [6, 256, 14, 14] [6, 256, 14, 14] --\n", + "│ │ └─Conv2d: 3-118 [6, 256, 14, 14] [6, 1024, 14, 14] 262,144\n", + "│ │ └─BatchNorm2d: 3-119 [6, 1024, 14, 14] [6, 1024, 14, 14] 2,048\n", + "│ │ └─ReLU: 3-120 [6, 1024, 14, 14] [6, 1024, 14, 14] --\n", + "├─Sequential: 1-8 [6, 1024, 14, 14] [6, 2048, 7, 7] --\n", + "│ └─Bottleneck: 2-14 [6, 1024, 14, 14] [6, 2048, 7, 7] --\n", + "│ │ └─Conv2d: 3-121 [6, 1024, 14, 14] [6, 512, 14, 14] 524,288\n", + "│ │ └─BatchNorm2d: 3-122 [6, 512, 14, 14] [6, 512, 14, 14] 1,024\n", + "│ │ └─ReLU: 3-123 [6, 512, 14, 14] [6, 512, 14, 14] --\n", + "│ │ └─Conv2d: 3-124 [6, 512, 14, 14] [6, 512, 7, 7] 2,359,296\n", + "│ │ └─BatchNorm2d: 3-125 [6, 512, 7, 7] [6, 512, 7, 7] 1,024\n", + "│ │ └─ReLU: 3-126 [6, 512, 7, 7] [6, 512, 7, 7] --\n", + "│ │ └─Conv2d: 3-127 [6, 512, 7, 7] [6, 2048, 7, 7] 1,048,576\n", + "│ │ └─BatchNorm2d: 3-128 [6, 2048, 7, 7] [6, 2048, 7, 7] 4,096\n", + "│ │ └─Sequential: 3-129 [6, 1024, 14, 14] [6, 2048, 7, 7] 2,101,248\n", + "│ │ └─ReLU: 3-130 [6, 2048, 7, 7] [6, 2048, 7, 7] --\n", + "│ └─Bottleneck: 2-15 [6, 2048, 7, 7] [6, 2048, 7, 7] --\n", + "│ │ └─Conv2d: 3-131 [6, 2048, 7, 7] [6, 512, 7, 7] 1,048,576\n", + "│ │ └─BatchNorm2d: 3-132 [6, 512, 7, 7] [6, 512, 7, 7] 1,024\n", + "│ │ └─ReLU: 3-133 [6, 512, 7, 7] [6, 512, 7, 7] --\n", + "│ │ └─Conv2d: 3-134 [6, 512, 7, 7] [6, 512, 7, 7] 2,359,296\n", + "│ │ └─BatchNorm2d: 3-135 [6, 512, 7, 7] [6, 512, 7, 7] 1,024\n", + "│ │ └─ReLU: 3-136 [6, 512, 7, 7] [6, 512, 7, 7] --\n", + "│ │ └─Conv2d: 3-137 [6, 512, 7, 7] [6, 2048, 7, 7] 1,048,576\n", + "│ │ └─BatchNorm2d: 3-138 [6, 2048, 7, 7] [6, 2048, 7, 7] 4,096\n", + "│ │ └─ReLU: 3-139 [6, 2048, 7, 7] [6, 2048, 7, 7] --\n", + "│ └─Bottleneck: 2-16 [6, 2048, 7, 7] [6, 2048, 7, 7] --\n", + "│ │ └─Conv2d: 3-140 [6, 2048, 7, 7] [6, 512, 7, 7] 1,048,576\n", + "│ │ └─BatchNorm2d: 3-141 [6, 512, 7, 7] [6, 512, 7, 7] 1,024\n", + "│ │ └─ReLU: 3-142 [6, 512, 7, 7] [6, 512, 7, 7] --\n", + "│ │ └─Conv2d: 3-143 [6, 512, 7, 7] [6, 512, 7, 7] 2,359,296\n", + "│ │ └─BatchNorm2d: 3-144 [6, 512, 7, 7] [6, 512, 7, 7] 1,024\n", + "│ │ └─ReLU: 3-145 [6, 512, 7, 7] [6, 512, 7, 7] --\n", + "│ │ └─Conv2d: 3-146 [6, 512, 7, 7] [6, 2048, 7, 7] 1,048,576\n", + "│ │ └─BatchNorm2d: 3-147 [6, 2048, 7, 7] [6, 2048, 7, 7] 4,096\n", + "│ │ └─ReLU: 3-148 [6, 2048, 7, 7] [6, 2048, 7, 7] --\n", + "├─AdaptiveAvgPool2d: 1-9 [6, 2048, 7, 7] [6, 2048, 1, 1] --\n", + "├─Linear: 1-10 [6, 2048] [6, 1000] 2,049,000\n", + "===================================================================================================================\n", + "Total params: 25,557,032\n", + "Trainable params: 25,557,032\n", + "Non-trainable params: 0\n", + "Total mult-adds (Units.GIGABYTES): 24.54\n", + "===================================================================================================================\n", + "Input size (MB): 3.61\n", + "Forward/backward pass size (MB): 1066.99\n", + "Params size (MB): 102.23\n", + "Estimated Total Size (MB): 1172.83\n", + "===================================================================================================================" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "resnet_model = resnet50(weights=ResNet50_Weights.DEFAULT)\n", "summary(resnet_model,\n", @@ -4055,10 +5148,196 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 64, "id": "5c8e359d", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "ResNet(\n", + " (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", + " (layer1): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer2): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer3): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (4): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (5): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer4): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n", + " (fc): Linear(in_features=2048, out_features=1000, bias=True)\n", + ")" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "resnet_model.eval()" ] @@ -4077,7 +5356,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 65, "id": "80f19869", "metadata": {}, "outputs": [], @@ -4098,7 +5377,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 66, "id": "6892597d", "metadata": {}, "outputs": [], @@ -4117,7 +5396,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 67, "id": "3eb1e1b0", "metadata": {}, "outputs": [], @@ -4142,10 +5421,47 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 68, "id": "0e89d251", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image: book_images/flamingo.jpg\n", + " label prob\n", + "0 flamingo 0.591760\n", + "1 spoonbill 0.012386\n", + "2 American_egret 0.002105\n", + "Image: book_images/hawk.jpg\n", + " label prob\n", + "0 great_grey_owl 0.287958\n", + "1 kite 0.039478\n", + "2 fountain 0.029384\n", + "Image: book_images/hawk_cropped.jpeg\n", + " label prob\n", + "0 kite 0.301841\n", + "1 jay 0.121659\n", + "2 magpie 0.015511\n", + "Image: book_images/huey.jpg\n", + " label prob\n", + "0 Lhasa 0.151153\n", + "1 Shih-Tzu 0.129804\n", + "2 Tibetan_terrier 0.102400\n", + "Image: book_images/kitty.jpg\n", + " label prob\n", + "0 tabby 0.173628\n", + "1 tiger_cat 0.110415\n", + "2 doormat 0.093447\n", + "Image: book_images/weaver.jpg\n", + " label prob\n", + "0 jacamar 0.287284\n", + "1 bee_eater 0.046768\n", + "2 bulbul 0.037507\n" + ] + } + ], "source": [ "for i, imgfile in enumerate(imgfiles):\n", " img_df = class_labels.copy()\n", @@ -4169,7 +5485,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 69, "id": "69456669", "metadata": {}, "outputs": [], @@ -4210,10 +5526,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 70, "id": "70b3ece2", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1, 14, 22, 16, 43, 530, 973, 1622, 1385, 65, 458,\n", + " 4468], dtype=int32)" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "(imdb_seq_train,\n", " imdb_seq_test) = load_sequential(root='data/IMDB')\n", @@ -4241,10 +5569,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 71, "id": "349b2af7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "\" this film was just brilliant casting location scenery story direction everyone's\"" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "lookup = load_lookup(root='data/IMDB')\n", "' '.join(lookup[i] for i in sample_review)" @@ -4264,7 +5603,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 72, "id": "ffa8da37", "metadata": {}, "outputs": [], @@ -4289,7 +5628,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 73, "id": "11eeeabb", "metadata": {}, "outputs": [], @@ -4324,10 +5663,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 74, "id": "5fe55a29", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "===================================================================================================================\n", + "Layer (type:depth-idx) Input Shape Output Shape Param #\n", + "===================================================================================================================\n", + "IMDBModel [25000, 10003] [25000] --\n", + "├─Linear: 1-1 [25000, 10003] [25000, 16] 160,064\n", + "├─ReLU: 1-2 [25000, 16] [25000, 16] --\n", + "├─Linear: 1-3 [25000, 16] [25000, 16] 272\n", + "├─ReLU: 1-4 [25000, 16] [25000, 16] --\n", + "├─Linear: 1-5 [25000, 16] [25000, 1] 17\n", + "===================================================================================================================\n", + "Total params: 160,353\n", + "Trainable params: 160,353\n", + "Non-trainable params: 0\n", + "Total mult-adds (Units.GIGABYTES): 4.01\n", + "===================================================================================================================\n", + "Input size (MB): 1000.30\n", + "Forward/backward pass size (MB): 6.60\n", + "Params size (MB): 0.64\n", + "Estimated Total Size (MB): 1007.54\n", + "===================================================================================================================" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "imdb_model = IMDBModel(imdb_test.tensors[0].size()[1])\n", "summary(imdb_model,\n", @@ -4356,7 +5725,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 75, "id": "e1ebbc70", "metadata": {}, "outputs": [], @@ -4379,10 +5748,494 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 76, "id": "9feddeb2", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "--------------------------------------------\n", + "0 | model | IMDBModel | 160 K \n", + "1 | loss | BCEWithLogitsLoss | 0 \n", + "--------------------------------------------\n", + "160 K Trainable params\n", + "0 Non-trainable params\n", + "160 K Total params\n", + "0.641 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_311/lib/python3.11/site-packages/pytorch_lightning/loops/fit_loop.py:280: PossibleUserWarning: The number of training batches (45) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n", + " rank_zero_warn(\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0a106ac0002a41c79a07179ac9ac79d3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=30` reached.\n" + ] + } + ], "source": [ "imdb_logger = CSVLogger('logs', name='IMDB')\n", "imdb_trainer = Trainer(deterministic=True,\n", @@ -4403,10 +6256,47 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 77, "id": "887d7dad", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "064dd0103e9e496f871b4f53bd3d1bf6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Testing: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", + "Runningstage.testing metric DataLoader 0\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", + " test_accuracy 0.8492799997329712\n", + " test_loss 1.2849037647247314\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n" + ] + }, + { + "data": { + "text/plain": [ + "[{'test_loss': 1.2849037647247314, 'test_accuracy': 0.8492799997329712}]" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "test_results = imdb_trainer.test(imdb_module, datamodule=imdb_dm)\n", "test_results" @@ -4426,7 +6316,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 78, "id": "055a9aeb", "metadata": {}, "outputs": [], @@ -4450,7 +6340,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 79, "id": "e3e1e181", "metadata": {}, "outputs": [], @@ -4473,7 +6363,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 80, "id": "dd64350c", "metadata": {}, "outputs": [], @@ -4495,7 +6385,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 81, "id": "0bf8b868", "metadata": {}, "outputs": [], @@ -4521,7 +6411,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 82, "id": "28256828", "metadata": {}, "outputs": [], @@ -4541,7 +6431,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 83, "id": "a5945618", "metadata": {}, "outputs": [], @@ -4582,10 +6472,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 84, "id": "74704884", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "imdb_results = pd.read_csv(imdb_logger.experiment.metrics_file_path)\n", "summary_plot(imdb_results,\n", @@ -4615,7 +6517,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 85, "id": "b1ecfca8", "metadata": {}, "outputs": [], @@ -4659,7 +6561,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 86, "id": "5503cb3f", "metadata": {}, "outputs": [], @@ -4702,7 +6604,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 87, "id": "8b683641", "metadata": {}, "outputs": [], @@ -4731,10 +6633,38 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 88, "id": "702aa8de", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "===================================================================================================================\n", + "Layer (type:depth-idx) Input Shape Output Shape Param #\n", + "===================================================================================================================\n", + "LSTMModel [10, 500] [10] --\n", + "├─Embedding: 1-1 [10, 500] [10, 500, 32] 320,096\n", + "├─LSTM: 1-2 [10, 500, 32] [10, 500, 32] 8,448\n", + "├─Linear: 1-3 [10, 32] [10, 1] 33\n", + "===================================================================================================================\n", + "Total params: 328,577\n", + "Trainable params: 328,577\n", + "Non-trainable params: 0\n", + "Total mult-adds (Units.MEGABYTES): 45.44\n", + "===================================================================================================================\n", + "Input size (MB): 50.00\n", + "Forward/backward pass size (MB): 2.56\n", + "Params size (MB): 1.31\n", + "Estimated Total Size (MB): 53.87\n", + "===================================================================================================================" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "lstm_model = LSTMModel(X_test.shape[-1])\n", "summary(lstm_model,\n", @@ -4755,7 +6685,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 89, "id": "e48aa272", "metadata": {}, "outputs": [], @@ -4766,10 +6696,346 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 90, "id": "143be7e8", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "--------------------------------------------\n", + "0 | model | LSTMModel | 328 K \n", + "1 | loss | BCEWithLogitsLoss | 0 \n", + "--------------------------------------------\n", + "328 K Trainable params\n", + "0 Non-trainable params\n", + "328 K Total params\n", + "1.314 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "27d0e8faa1244bd0831926af5106cbf3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=20` reached.\n" + ] + } + ], "source": [ "lstm_trainer = Trainer(deterministic=True,\n", " max_epochs=20,\n", @@ -4790,10 +7056,47 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 91, "id": "9272e2ba", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "256aa50618b349c9b60b72ead019ca44", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Testing: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", + "Runningstage.testing metric DataLoader 0\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", + " test_accuracy 0.863319993019104\n", + " test_loss 0.7284740209579468\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n" + ] + }, + { + "data": { + "text/plain": [ + "[{'test_loss': 0.7284740209579468, 'test_accuracy': 0.863319993019104}]" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "lstm_trainer.test(lstm_module, datamodule=imdb_seq_dm)" ] @@ -4808,10 +7111,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 92, "id": "5d9d387e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(0.5, 1.0)" + ] + }, + "execution_count": 92, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "lstm_results = pd.read_csv(lstm_logger.experiment.metrics_file_path)\n", "fig, ax = subplots(1, 1, figsize=(6, 6))\n", @@ -4826,7 +7150,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 93, "id": "7c6d1072", "metadata": {}, "outputs": [], @@ -4852,7 +7176,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 94, "id": "8e2d1d5c", "metadata": {}, "outputs": [], @@ -4877,7 +7201,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 95, "id": "6f6d0e12", "metadata": {}, "outputs": [], @@ -4902,10 +7226,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 96, "id": "d3c961ec", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['DJ_return_1', 'log_volume_1', 'log_volatility_1', 'DJ_return_2',\n", + " 'log_volume_2', 'log_volatility_2', 'DJ_return_3', 'log_volume_3',\n", + " 'log_volatility_3', 'DJ_return_4', 'log_volume_4', 'log_volatility_4',\n", + " 'DJ_return_5', 'log_volume_5', 'log_volatility_5'],\n", + " dtype='object')" + ] + }, + "execution_count": 96, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "Y, train = X['log_volume'], X['train']\n", "X = X.drop(columns=['train'] + cols)\n", @@ -4923,10 +7262,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 97, "id": "cb89da88", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "0.4128912938562521" + ] + }, + "execution_count": 97, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "M = LinearRegression()\n", "M.fit(X[train], Y[train])\n", @@ -4945,7 +7295,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 98, "id": "55d921d7", "metadata": {}, "outputs": [], @@ -4967,10 +7317,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 99, "id": "4e87eeb9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "0.45633025715446285" + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "M.fit(X_day[train], Y[train])\n", "M.score(X_day[~train], Y[~train])" @@ -5006,10 +7367,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 100, "id": "3689b318", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['DJ_return_5', 'log_volume_5', 'log_volatility_5', 'DJ_return_4',\n", + " 'log_volume_4', 'log_volatility_4', 'DJ_return_3', 'log_volume_3',\n", + " 'log_volatility_3', 'DJ_return_2', 'log_volume_2', 'log_volatility_2',\n", + " 'DJ_return_1', 'log_volume_1', 'log_volatility_1'],\n", + " dtype='object')" + ] + }, + "execution_count": 100, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "ordered_cols = []\n", "for lag in range(5,0,-1):\n", @@ -5029,10 +7405,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 101, "id": "5633e521", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(6046, 5, 3)" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "X_rnn = X.to_numpy().reshape((-1,5,3))\n", "X_rnn.shape" @@ -5054,7 +7441,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 102, "id": "979a6066", "metadata": {}, "outputs": [], @@ -5091,7 +7478,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 103, "id": "3528f4e7", "metadata": {}, "outputs": [], @@ -5114,10 +7501,38 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 104, "id": "795c283e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "===================================================================================================================\n", + "Layer (type:depth-idx) Input Shape Output Shape Param #\n", + "===================================================================================================================\n", + "NYSEModel [1770, 5, 3] [1770] --\n", + "├─RNN: 1-1 [1770, 5, 3] [1770, 5, 12] 204\n", + "├─Dropout: 1-2 [1770, 12] [1770, 12] --\n", + "├─Linear: 1-3 [1770, 12] [1770, 1] 13\n", + "===================================================================================================================\n", + "Total params: 217\n", + "Trainable params: 217\n", + "Non-trainable params: 0\n", + "Total mult-adds (Units.MEGABYTES): 1.83\n", + "===================================================================================================================\n", + "Input size (MB): 0.11\n", + "Forward/backward pass size (MB): 0.86\n", + "Params size (MB): 0.00\n", + "Estimated Total Size (MB): 0.97\n", + "===================================================================================================================" + ] + }, + "execution_count": 104, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "summary(nyse_model,\n", " input_data=X_rnn_t,\n", @@ -5138,7 +7553,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 105, "id": "31640121", "metadata": {}, "outputs": [], @@ -5160,10 +7575,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 106, "id": "af6795f5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([64]) torch.Size([64])\n", + "torch.Size([64]) torch.Size([64])\n", + "torch.Size([64]) torch.Size([64])\n" + ] + } + ], "source": [ "for idx, (x, y) in enumerate(nyse_dm.train_dataloader()):\n", " out = nyse_model(x)\n", @@ -5184,7 +7609,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 107, "id": "0d04344c", "metadata": {}, "outputs": [], @@ -5207,10 +7632,2902 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 108, "id": "485d7bb1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------\n", + "0 | model | NYSEModel | 217 \n", + "1 | loss | MSELoss | 0 \n", + "------------------------------------\n", + "217 Trainable params\n", + "0 Non-trainable params\n", + "217 Total params\n", + "0.001 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "affbe15b2aea4502be055f549b56b859", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "df31485ea2c1411eb581e0ef4aca2e46", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1e7a6942d3da4ac7812c06d6001d5752", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a553d9a510f340d2bf088214efb11862", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4568e759e2d04d8ab6fa3a4eed0b3d5a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a5b922f3202f4412951227d70602c03d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "69dda18b699c4807a18fdf2095f4bce7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6b4e606347a34646ab4490f5b2e677aa", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f929604d19a24e9c973906645080361d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4c680e8b8f7c4c089f1b0862efa300df", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4d7f5a5db7fe4dad83adca80ab6e5104", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c96b9fc5856242ffbba38b841aeb2fcd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0e4ebdf1ca1d42b681a1de452f8fe5cb", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8d26fb78adaf4723b79752599984871b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "83e98660a87d4f23ac38855cd0b7d2a1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d32c241594674df6bd92fc3750b27bcd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1ed9ef10d08741848b5c12c0589bddde", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b39de6629c4349f6a9f40d1e3e6f87a4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cfa35246d8384ddf8b7d3ca84ff5fa6e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "04172e9eac3a4514bb929200b3c5cbea", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2846ef61e1ab4cc9adac3b47acda8bc6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "df9e5f5b8e9844e3a9530fcc17ae3062", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5789e5d108d04005a7e05960d9d11bdb", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "08ed274deec74792a5aaa6b53316beef", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "eb8d070eed0646c59324c4632358970a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4831d7f9ce4b45508b5216fb501600e4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4fee7150dde148f6a64b298d100d6bb8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f9758b9ff7694c13baa998f7a172e678", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "77c264e33ab94ad193bcce6a4ff679ff", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "895feca2fe02488a9326798d3cb9256e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8730064093b54a809406f68a8136d00f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9b4446b771c048f2a7f18a273dadeaf4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a740b87f3db54055817f9b3aa0a2a958", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "165516a1fc294d8fa7982a2676a092a5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "93f3fc911d484af6996c1068ea81ac4e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0bc5b01868d04deea69acd8b770b27e0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "df1916189a654aaca809001103e4f82a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c11c353546274a85b6508c27da19f2fc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0bc594ec20474d99a6bfacc921a9abfc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "908c3a04e2164fa6854c4c4c7fdfd3dc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cd4a107aad0e48598fdae25f044ea57b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a28d76cd6695406c81bd9cce2722066a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "73692b2969a945ee8c50349f4153b45b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "548080a500dc496a8de4db8e2185fce3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ee2e33a424664acd86ff08b1adc0c969", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f95edd16b52a4b67ae3d54a692e36170", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0b26121eef9b4da89a8160fc59f6512b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "505001dfaaf840a08e2ed4631598de5b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3b17f8cbe62b4c6c9d0eb8467dc7114c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "27a8ba3e6cde4a929916da4020421d42", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "51f5f007dfdc41adafa4998e9859a07a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b0ed943804c645cbb46a20a92f9ec0a4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a6351ad426b7401fa20edaeb40a89d6d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2935ea747ea949b88bb4f741657d3b26", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ee8d475a6c724357bf87a4272637a6bf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "acea0ebaddd14a66a8e4ac4d0e6950e4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "548ef3a5d67d4511b6aba31cabca8ebf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c5e311f7977a41538959e316dfa3c495", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b5f6492745894af3996b48190f3f2e7b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "56a3f56322f64998a5ad676e579ffe40", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fb95d345c765493e806cffd9e0f87478", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "67f8a02332d24c6788b82e71deed5166", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "93cf405be38b41dfa1188c39596d83af", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3bd736f5ab1f4e799d1f469a05ab4ba9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cac3cb3359a248d49b1286ef390c8757", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8f5ffabedce248a680f95cf5bfabaa74", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7864b19723724e4ba19245944ed865af", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a39780f54f6c4687a93ce7ed10273aef", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0397c25bd3dc4822b4ed730d353e86c6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fb98dbf5f43849dfa2dbddba0904fb24", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ad6953c9cf8b4a479c5281590423721a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "810b7eb00dd3434594f30d653b835de8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ece01df6257a4e79bff7d059733195af", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d94ab3b3a92b4951950f6c8acb90dd29", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "82d9c8d77b234ead9fc9e3b0463f1a20", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f616c9393fe6479697f99231d6eaf367", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "09718f40ac3a44dd95200a6a1943d515", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d2431f57436e4d5e836bc672341de83c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "33804f115ba34ce78ebede53588e7093", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4133b7292ea94856b2e96cc423f6b4a4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3431bfac65d74ce5a9ca9357e710ede8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0b2a8840cf8f4148805adaf3dfb702e3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a67d21d65a19474684d6e5dd888a4238", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b5403484dfa340118cd7afafcd935be8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f7350f32595d4ba983c483975b6cfd0e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d7370199868346578b31190622bbccc3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "23ca723ac6b2442cb7a69044d3af971b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0241789fb88e4d27b793b26c973e01e0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9069b055a1ef4ab3be7697e9cfcd2dae", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "db629f64c7e445cca1e201e98541186b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1835f814bdf04d149fe855bbdf88633e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7f2bc04f4a2b4a87bdd7e46aa4d77664", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ff74b552224043eca02d8dc2ec196a8c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "435a11e9c3fc46e4938bac968ae0be2d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "24bec653c5954c30838bc62b1fdb5316", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0a47c3ffba28416e97643cc1655909ce", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b3d54e6f279b4c12b98bd3e67954c779", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "163ab04c6a5a41c1b7e8b2fd78a83c42", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "414cc0fc90034158a66be1f612761144", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ab3b22effed845ceb4dd0740d3bc2c41", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c3df86ffdf4e4a119d9ee15cc006a9cf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "590fa45887624de6bfbdefbccb9168e3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "97fd033265974053b2000d55ee1379c6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "37702ceb22b649839885931af3237449", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "166df1337a404ab295da926b45ec3e04", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9f8d20cd076545eabb685dacfa1ba5e2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3ec75716f53a4860afc80e4dcea18437", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8852f5418920497d9591ef58b29f5f92", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b3614c9697d644e1a2bb95cd9f7fe3fb", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bdcc14e2eb0e4d2988c079bbd759ca03", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6fe0b06582584c419448938aa04c5fd6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f65429b4d1734fc4aff066563b0266c2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "09cfe5ca53db49ea9d02c4e09f0af3a7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7bc12dc890bf4d1dab9eebf799efb090", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7523bb8de5d84e17a63aefaae0fdda31", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1cf00643676148f8915a44b94fbf712b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f3f27fb5c70b456196dd848576ac6a9d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "dc018c4300e04248a49f9800939ed516", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "35fd6bf19b9c410e87e8e8f1526f00d3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b7b1bfc40e074df187732eff75cc90db", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ef4326a0e0ce4fadb6c9a760b421aab1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6c555de612e2438ab70db1454085d141", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "608c586f2b044308a508e058724f1e36", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "42ea1fa9502e42068c27ae19c2a09684", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "90170b9b233a478b90b3b1bb04049985", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e0af4bb835da4ee9a57bb2afd34a3f81", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fc078b7a914347069d3fef639941119f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "daf05918764f43f5bf6d51411a9648ab", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "232862aca5134623bf134361217a3b93", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4e36f3f5cebb4f698db5f38d28b0a869", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f9967a77d7bd44e38c38fffb3689988d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c119f50cb2cc4e1db50e6f5cbfe3ac86", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bbb5138244a24e0fbf47a9e309160ee1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "95e306ba9da24c3194dd725d36dc31c8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ce9b1f0cda974946884e1722b8e58c8f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4a51a61743964cf7978fad1a601538d2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f48eff432bda41c69de09f8bc5593840", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ecef0f9dd3ee4c97b46fb79300f78622", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1d67181c33334c4e97f00e52a2388b3d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4293aa1879964c5f96e01b5431f9a860", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4b6d94ff7dd64b0aaf0207fb848b6cf3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a87cefecac924e548d6c90cd5e879075", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b0fad65d603048e388a8f38be42006b8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2c5986161cec4f11b7dcd1f5d4fdc4e0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f6ca9f16c09847a09114747eb9ca6e8c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8d5f742d0d484e0f8fbb8e772977d141", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "80c9b3af7d334fa4a357119f01da979d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c91b1c80250c4e2ea1aca65ccbbbb51e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "967b2b121fb048c68d88dc8e2a28cef9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ec7815c846e844c9ad5a2b52e78a4522", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "41b83a381e544b1b805197f28297685f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "771f16646e5a489cbded40801775eeeb", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "252f30a605374f9d93212481bde300c5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "99b95d1622524a3e95179bbd206541b9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=200` reached.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "aa4b8ff668e44084b675cb86f3d28ab1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Testing: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", + "Runningstage.testing metric DataLoader 0\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", + " test_loss 0.6186699867248535\n", + " test_r2 0.4128519892692566\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n" + ] + }, + { + "data": { + "text/plain": [ + "[{'test_loss': 0.6186699867248535, 'test_r2': 0.4128519892692566}]" + ] + }, + "execution_count": 108, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "nyse_trainer = Trainer(deterministic=True,\n", " max_epochs=200,\n", @@ -5239,7 +10556,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 109, "id": "91d6633a", "metadata": {}, "outputs": [], @@ -5263,7 +10580,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 110, "id": "87137503", "metadata": {}, "outputs": [], @@ -5285,7 +10602,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 111, "id": "3cf09a55", "metadata": {}, "outputs": [], @@ -5304,7 +10621,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 112, "id": "930576f3", "metadata": {}, "outputs": [], @@ -5328,7 +10645,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 113, "id": "b9ae8d0e", "metadata": { "scrolled": true @@ -5371,7 +10688,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "49a11b07bdd648fe98b855178b3ada60", + "model_id": "79ff594439b144f5a1c275960213aa5c", "version_major": 2, "version_minor": 0 }, @@ -5672,7 +10989,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a31407a5ed78444ea0cd603135a34997", + "model_id": "84cfd4145b114cb286ee3b3b27ab3c56", "version_major": 2, "version_minor": 0 },