From 322b7ec7ac3906157f808da84c23b9388996f23c Mon Sep 17 00:00:00 2001 From: Jonathan Taylor Date: Wed, 26 Jul 2023 08:38:53 -0400 Subject: [PATCH] deep learning, multiple --- Ch10-deeplearning-lab.ipynb | 7157 ++++++++++++++++++++++++++++++++++- Ch13-multiple-lab.ipynb | 248 +- 2 files changed, 7120 insertions(+), 285 deletions(-) diff --git a/Ch10-deeplearning-lab.ipynb b/Ch10-deeplearning-lab.ipynb index 61de0ed..516f3c8 100644 --- a/Ch10-deeplearning-lab.ipynb +++ b/Ch10-deeplearning-lab.ipynb @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "aeb913e2", "metadata": { "lines_to_next_cell": 2 @@ -60,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "3a3e91e7", "metadata": {}, "outputs": [], @@ -86,7 +86,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "3f4fdb8c", "metadata": {}, "outputs": [], @@ -111,7 +111,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "71cc6f03", "metadata": {}, "outputs": [], @@ -131,10 +131,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "fd1290f1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Global seed set to 0\n" + ] + } + ], "source": [ "from pytorch_lightning.utilities.seed import seed_everything\n", "seed_everything(0, workers=True)\n", @@ -153,7 +161,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "c85308d1", "metadata": { "lines_to_next_cell": 0 @@ -188,7 +196,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "4de9f03c", "metadata": {}, "outputs": [], @@ -217,7 +225,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "4ef95fe3", "metadata": {}, "outputs": [], @@ -246,7 +254,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "493821a9", "metadata": { "lines_to_next_cell": 2 @@ -268,7 +276,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "a427e224", "metadata": { "lines_to_next_cell": 0 @@ -296,7 +304,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "feac4b15", "metadata": { "lines_to_next_cell": 0 @@ -332,7 +340,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "6a75a640", "metadata": {}, "outputs": [], @@ -357,10 +365,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "32d8de64", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "259.71528833146243" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "hit_lm = LinearRegression().fit(X_train, Y_train)\n", "Yhat_test = hit_lm.predict(X_test)\n", @@ -382,7 +401,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "46786db6", "metadata": {}, "outputs": [], @@ -405,7 +424,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "2b55b38b", "metadata": { "lines_to_next_cell": 0 @@ -430,7 +449,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "cc44c559", "metadata": {}, "outputs": [], @@ -457,12 +476,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "1bd1fd13", "metadata": { "lines_to_next_cell": 0 }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "257.2382010799497" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "trained_lasso = grid.best_estimator_\n", "Yhat_test = trained_lasso.predict(X_test)\n", @@ -488,7 +518,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "4b2ccc5a", "metadata": {}, "outputs": [], @@ -546,7 +576,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "108ad1f1", "metadata": {}, "outputs": [], @@ -581,12 +611,53 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "2f20059e", "metadata": { "lines_to_next_cell": 0 }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_39/lib/python3.9/site-packages/torchinfo/torchinfo.py:477: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly. To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()\n", + " action_fn=lambda data: sys.getsizeof(data.storage()),\n", + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_39/lib/python3.9/site-packages/torch/storage.py:665: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly. To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()\n", + " return super().__sizeof__() + self.nbytes()\n" + ] + }, + { + "data": { + "text/plain": [ + "===================================================================================================================\n", + "Layer (type:depth-idx) Input Shape Output Shape Param #\n", + "===================================================================================================================\n", + "HittersModel [175, 19] [175] --\n", + "├─Flatten: 1-1 [175, 19] [175, 19] --\n", + "├─Sequential: 1-2 [175, 19] [175, 1] --\n", + "│ └─Linear: 2-1 [175, 19] [175, 50] 1,000\n", + "│ └─ReLU: 2-2 [175, 50] [175, 50] --\n", + "│ └─Dropout: 2-3 [175, 50] [175, 50] --\n", + "│ └─Linear: 2-4 [175, 50] [175, 1] 51\n", + "===================================================================================================================\n", + "Total params: 1,051\n", + "Trainable params: 1,051\n", + "Non-trainable params: 0\n", + "Total mult-adds (M): 0.18\n", + "===================================================================================================================\n", + "Input size (MB): 0.01\n", + "Forward/backward pass size (MB): 0.07\n", + "Params size (MB): 0.00\n", + "Estimated Total Size (MB): 0.09\n", + "===================================================================================================================" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "summary(hit_model, \n", " input_size=X_train.shape,\n", @@ -618,7 +689,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "6ca3030d", "metadata": { "lines_to_next_cell": 0 @@ -640,7 +711,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "86723b3e", "metadata": {}, "outputs": [], @@ -675,7 +746,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "id": "999279fd", "metadata": {}, "outputs": [], @@ -707,7 +778,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "id": "7bd9cc5c", "metadata": {}, "outputs": [], @@ -735,7 +806,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "id": "5be2f822", "metadata": {}, "outputs": [], @@ -762,7 +833,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "id": "87334d33", "metadata": {}, "outputs": [], @@ -793,12 +864,709 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "id": "1a474999", "metadata": { "lines_to_next_cell": 0 }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_39/lib/python3.9/site-packages/pytorch_lightning/trainer/trainer.py:1789: UserWarning: MPS available but not used. Set `accelerator` and `devices` using `Trainer(accelerator='mps', devices=1)`.\n", + " rank_zero_warn(\n", + "\n", + " | Name | Type | Params\n", + "---------------------------------------\n", + "0 | model | HittersModel | 1.1 K \n", + "1 | loss | MSELoss | 0 \n", + "---------------------------------------\n", + "1.1 K Trainable params\n", + "0 Non-trainable params\n", + "1.1 K Total params\n", + "0.004 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": "7f1f820ee6fa4d81a3736b68611f3bac", + "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" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\n" + ] + } + ], "source": [ "hit_trainer = Trainer(deterministic=True,\n", " max_epochs=50,\n", @@ -825,12 +1593,49 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "id": "e3b24643", "metadata": { "lines_to_next_cell": 2 }, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ce9e57deabef4f55aba22efb507872f1", + "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", + " Test metric DataLoader 0\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", + " test_loss 103304.8515625\n", + " test_mae 224.26962280273438\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n" + ] + }, + { + "data": { + "text/plain": [ + "[{'test_loss': 103304.8515625, 'test_mae': 224.26962280273438}]" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "hit_trainer.test(hit_module, datamodule=hit_dm)\n" ] @@ -852,7 +1657,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "id": "f9b266e7", "metadata": {}, "outputs": [], @@ -871,7 +1676,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "id": "c5752a0b", "metadata": { "lines_to_next_cell": 0 @@ -914,12 +1719,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "id": "ff0c9fa0", "metadata": { "lines_to_next_cell": 2 }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, ax = subplots(1, 1, figsize=(6, 6))\n", "ax = summary_plot(hit_results,\n", @@ -950,12 +1766,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "id": "1ee2b61b", "metadata": { "lines_to_next_cell": 0 }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(224.2696, grad_fn=)" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "hit_model.eval() \n", "preds = hit_module(X_test_t)\n", @@ -984,7 +1811,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "id": "0ca069a3", "metadata": { "lines_to_next_cell": 2 @@ -1017,10 +1844,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "id": "af6a0a33", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Dataset MNIST\n", + " Number of datapoints: 60000\n", + " Root location: data\n", + " Split: Train\n", + " StandardTransform\n", + "Transform: ToTensor()" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "(mnist_train, \n", " mnist_test) = [MNIST(root='data',\n", @@ -1056,7 +1899,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "id": "0df8a0c8", "metadata": {}, "outputs": [], @@ -1079,12 +1922,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "id": "0c7dd6ee", "metadata": { "lines_to_next_cell": 2 }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X: torch.Size([256, 1, 28, 28])\n", + "Y: torch.Size([256])\n", + "X: torch.Size([256, 1, 28, 28])\n", + "Y: torch.Size([256])\n" + ] + } + ], "source": [ "for idx, (X_ ,Y_) in enumerate(mnist_dm.train_dataloader()):\n", " print('X: ', X_.shape)\n", @@ -1107,7 +1961,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "id": "63e48c70", "metadata": {}, "outputs": [], @@ -1147,7 +2001,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "id": "92405826", "metadata": {}, "outputs": [], @@ -1166,10 +2020,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 39, "id": "2c8f7a48", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([256, 10])" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "mnist_model(X_).size()" ] @@ -1186,10 +2051,56 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 40, "id": "9f502df8", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_39/lib/python3.9/site-packages/torchinfo/torchinfo.py:477: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly. To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()\n", + " action_fn=lambda data: sys.getsizeof(data.storage()),\n", + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_39/lib/python3.9/site-packages/torch/storage.py:665: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly. To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()\n", + " return super().__sizeof__() + self.nbytes()\n" + ] + }, + { + "data": { + "text/plain": [ + "===================================================================================================================\n", + "Layer (type:depth-idx) Input Shape Output Shape Param #\n", + "===================================================================================================================\n", + "MNISTModel [256, 1, 28, 28] [256, 10] --\n", + "├─Sequential: 1-1 [256, 1, 28, 28] [256, 10] --\n", + "│ └─Sequential: 2-1 [256, 1, 28, 28] [256, 256] --\n", + "│ │ └─Flatten: 3-1 [256, 1, 28, 28] [256, 784] --\n", + "│ │ └─Linear: 3-2 [256, 784] [256, 256] 200,960\n", + "│ │ └─ReLU: 3-3 [256, 256] [256, 256] --\n", + "│ │ └─Dropout: 3-4 [256, 256] [256, 256] --\n", + "│ └─Sequential: 2-2 [256, 256] [256, 128] --\n", + "│ │ └─Linear: 3-5 [256, 256] [256, 128] 32,896\n", + "│ │ └─ReLU: 3-6 [256, 128] [256, 128] --\n", + "│ │ └─Dropout: 3-7 [256, 128] [256, 128] --\n", + "│ └─Linear: 2-3 [256, 128] [256, 10] 1,290\n", + "===================================================================================================================\n", + "Total params: 235,146\n", + "Trainable params: 235,146\n", + "Non-trainable params: 0\n", + "Total mult-adds (M): 60.20\n", + "===================================================================================================================\n", + "Input size (MB): 0.80\n", + "Forward/backward pass size (MB): 0.81\n", + "Params size (MB): 0.94\n", + "Estimated Total Size (MB): 2.55\n", + "===================================================================================================================" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "summary(mnist_model,\n", " input_data=X_,\n", @@ -1211,7 +2122,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 41, "id": "d1a7590f", "metadata": {}, "outputs": [], @@ -1230,12 +2141,490 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 42, "id": "e2fe6de3", "metadata": { "lines_to_next_cell": 0 }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_39/lib/python3.9/site-packages/pytorch_lightning/trainer/trainer.py:1789: UserWarning: MPS available but not used. Set `accelerator` and `devices` using `Trainer(accelerator='mps', devices=1)`.\n", + " rank_zero_warn(\n", + "\n", + " | Name | Type | Params\n", + "-------------------------------------------\n", + "0 | model | MNISTModel | 235 K \n", + "1 | loss | CrossEntropyLoss | 0 \n", + "-------------------------------------------\n", + "235 K Trainable params\n", + "0 Non-trainable params\n", + "235 K Total params\n", + "0.941 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": "82f9178e94874e7e9cbb3b27cc1c351f", + "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": [ "mnist_trainer = Trainer(deterministic=True,\n", " max_epochs=30,\n", @@ -1277,12 +2666,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 43, "id": "73755987", "metadata": { "lines_to_next_cell": 0 }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "mnist_results = pd.read_csv(mnist_logger.experiment.metrics_file_path)\n", "fig, ax = subplots(1, 1, figsize=(6, 6))\n", @@ -1306,10 +2706,47 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 44, "id": "f5269c40", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b584fa2b09df4c20939181c016e85bc5", + "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", + " Test metric DataLoader 0\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", + " test_accuracy 0.9681000113487244\n", + " test_loss 0.14706705510616302\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n" + ] + }, + { + "data": { + "text/plain": [ + "[{'test_loss': 0.14706705510616302, 'test_accuracy': 0.9681000113487244}]" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "mnist_trainer.test(mnist_module,\n", " datamodule=mnist_dm)" @@ -1330,7 +2767,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 45, "id": "97a0b304", "metadata": {}, "outputs": [], @@ -1350,12 +2787,526 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 46, "id": "ea685183", "metadata": { "lines_to_next_cell": 0 }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_39/lib/python3.9/site-packages/pytorch_lightning/trainer/trainer.py:1789: UserWarning: MPS available but not used. Set `accelerator` and `devices` using `Trainer(accelerator='mps', devices=1)`.\n", + " rank_zero_warn(\n", + "\n", + " | Name | Type | Params\n", + "-------------------------------------------\n", + "0 | model | MNIST_MLR | 7.9 K \n", + "1 | loss | CrossEntropyLoss | 0 \n", + "-------------------------------------------\n", + "7.9 K Trainable params\n", + "0 Non-trainable params\n", + "7.9 K Total params\n", + "0.031 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": "02fd79458dc34808bb403f8b8475a62d", + "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": "9c827fce3589462294778b990fc78f2f", + "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": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\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": "a9fcb28681b34dc6921cad2630ca648f", + "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": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\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": "e2dd237b55d14ad4a871888e4ecde25d", + "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": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\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": "5d8dc977673646d9ad09d0c5b7e4903a", + "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": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\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" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=30` reached.\n" + ] + } + ], "source": [ "mlr_trainer = Trainer(deterministic=True,\n", " max_epochs=30,\n", @@ -1373,12 +3324,49 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 47, "id": "c0bd63e3", "metadata": { "lines_to_next_cell": 0 }, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "92b4035b1656456d88d929aac0d46d71", + "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", + " Test metric DataLoader 0\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", + " test_accuracy 0.9240999817848206\n", + " test_loss 0.3186827003955841\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n" + ] + }, + { + "data": { + "text/plain": [ + "[{'test_loss': 0.3186827003955841, 'test_accuracy': 0.9240999817848206}]" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "mlr_trainer.test(mlr_module,\n", " datamodule=mnist_dm)" @@ -1397,7 +3385,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 48, "id": "6b0d3daa", "metadata": { "lines_to_next_cell": 2 @@ -1428,10 +3416,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 49, "id": "67517b11", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Files already downloaded and verified\n", + "Files already downloaded and verified\n" + ] + } + ], "source": [ "(cifar_train, \n", " cifar_test) = [CIFAR100(root=\"data\",\n", @@ -1442,7 +3439,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 50, "id": "ee7b040e", "metadata": {}, "outputs": [], @@ -1473,7 +3470,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 51, "id": "bd9e74ad", "metadata": { "lines_to_next_cell": 0 @@ -1497,12 +3494,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 52, "id": "a553b926", "metadata": { "lines_to_next_cell": 2 }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X: torch.Size([128, 3, 32, 32])\n", + "Y: torch.Size([128])\n", + "X: torch.Size([128, 3, 32, 32])\n", + "Y: torch.Size([128])\n" + ] + } + ], "source": [ "for idx, (X_ ,Y_) in enumerate(cifar_dm.train_dataloader()):\n", " print('X: ', X_.shape)\n", @@ -1525,12 +3533,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 53, "id": "94885e68", "metadata": { "lines_to_next_cell": 0 }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, axes = subplots(5, 5, figsize=(10,10))\n", "rng = np.random.default_rng(4)\n", @@ -1564,7 +3583,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 54, "id": "cdc2528a", "metadata": {}, "outputs": [], @@ -1609,7 +3628,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 55, "id": "845be1ae", "metadata": {}, "outputs": [], @@ -1645,12 +3664,69 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 56, "id": "be768cbb", "metadata": { "lines_to_next_cell": 2 }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_39/lib/python3.9/site-packages/torchinfo/torchinfo.py:477: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly. To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()\n", + " action_fn=lambda data: sys.getsizeof(data.storage()),\n", + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_39/lib/python3.9/site-packages/torch/storage.py:665: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly. To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()\n", + " return super().__sizeof__() + self.nbytes()\n" + ] + }, + { + "data": { + "text/plain": [ + "===================================================================================================================\n", + "Layer (type:depth-idx) Input Shape Output Shape Param #\n", + "===================================================================================================================\n", + "CIFARModel [128, 3, 32, 32] [128, 100] --\n", + "├─Sequential: 1-1 [128, 3, 32, 32] [128, 256, 2, 2] --\n", + "│ └─BuildingBlock: 2-1 [128, 3, 32, 32] [128, 32, 16, 16] --\n", + "│ │ └─Conv2d: 3-1 [128, 3, 32, 32] [128, 32, 32, 32] 896\n", + "│ │ └─ReLU: 3-2 [128, 32, 32, 32] [128, 32, 32, 32] --\n", + "│ │ └─MaxPool2d: 3-3 [128, 32, 32, 32] [128, 32, 16, 16] --\n", + "│ └─BuildingBlock: 2-2 [128, 32, 16, 16] [128, 64, 8, 8] --\n", + "│ │ └─Conv2d: 3-4 [128, 32, 16, 16] [128, 64, 16, 16] 18,496\n", + "│ │ └─ReLU: 3-5 [128, 64, 16, 16] [128, 64, 16, 16] --\n", + "│ │ └─MaxPool2d: 3-6 [128, 64, 16, 16] [128, 64, 8, 8] --\n", + "│ └─BuildingBlock: 2-3 [128, 64, 8, 8] [128, 128, 4, 4] --\n", + "│ │ └─Conv2d: 3-7 [128, 64, 8, 8] [128, 128, 8, 8] 73,856\n", + "│ │ └─ReLU: 3-8 [128, 128, 8, 8] [128, 128, 8, 8] --\n", + "│ │ └─MaxPool2d: 3-9 [128, 128, 8, 8] [128, 128, 4, 4] --\n", + "│ └─BuildingBlock: 2-4 [128, 128, 4, 4] [128, 256, 2, 2] --\n", + "│ │ └─Conv2d: 3-10 [128, 128, 4, 4] [128, 256, 4, 4] 295,168\n", + "│ │ └─ReLU: 3-11 [128, 256, 4, 4] [128, 256, 4, 4] --\n", + "│ │ └─MaxPool2d: 3-12 [128, 256, 4, 4] [128, 256, 2, 2] --\n", + "├─Sequential: 1-2 [128, 1024] [128, 100] --\n", + "│ └─Dropout: 2-5 [128, 1024] [128, 1024] --\n", + "│ └─Linear: 2-6 [128, 1024] [128, 512] 524,800\n", + "│ └─ReLU: 2-7 [128, 512] [128, 512] --\n", + "│ └─Linear: 2-8 [128, 512] [128, 100] 51,300\n", + "===================================================================================================================\n", + "Total params: 964,516\n", + "Trainable params: 964,516\n", + "Non-trainable params: 0\n", + "Total mult-adds (G): 2.01\n", + "===================================================================================================================\n", + "Input size (MB): 1.57\n", + "Forward/backward pass size (MB): 63.54\n", + "Params size (MB): 3.86\n", + "Estimated Total Size (MB): 68.97\n", + "===================================================================================================================" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "cifar_model = CIFARModel()\n", "summary(cifar_model,\n", @@ -1696,7 +3772,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 57, "id": "67e3e2d9", "metadata": {}, "outputs": [], @@ -1709,10 +3785,486 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 58, "id": "1ea339ff", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\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": "fdb66e85a34e49afafdf51191e247d54", + "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": [ "cifar_trainer = Trainer(deterministic=True,\n", " max_epochs=30,\n", @@ -1739,12 +4291,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 59, "id": "0a9068d9", "metadata": { "lines_to_next_cell": 0 }, - "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", @@ -1768,12 +4331,49 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 60, "id": "e71eff9b", "metadata": { "lines_to_next_cell": 2 }, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3e804034c1964ed38bbe2ca376491f54", + "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", + " Test metric DataLoader 0\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", + " test_accuracy 0.40880000591278076\n", + " test_loss 2.4764862060546875\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n" + ] + }, + { + "data": { + "text/plain": [ + "[{'test_loss': 2.4764862060546875, 'test_accuracy': 0.40880000591278076}]" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "cifar_trainer.test(cifar_module,\n", " datamodule=cifar_dm)\n" @@ -1801,12 +4401,510 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 61, "id": "58eae430", "metadata": { "lines_to_next_cell": 0 }, - "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": "ebeb3882e14340e8b43876442c7e36d9", + "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_39/lib/python3.9/site-packages/torchmetrics/utilities/checks.py:49: UserWarning: MPS: no support for int64 min/max ops, casting it to int32 (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/native/mps/operations/ReduceOps.mm:1271.)\n", + " if ignore_index is None and target.min() < 0:\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": "3436eeffcb544f009e93641c9b125c58", + "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", @@ -1855,12 +4953,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 62, "id": "638a1c8c", "metadata": { "lines_to_next_cell": 2 }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_39/lib/python3.9/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", @@ -1883,12 +5000,221 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 63, "id": "7776ed1e", "metadata": { "lines_to_next_cell": 0 }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_39/lib/python3.9/site-packages/torchinfo/torchinfo.py:477: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly. To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()\n", + " action_fn=lambda data: sys.getsizeof(data.storage()),\n", + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_39/lib/python3.9/site-packages/torch/storage.py:665: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly. To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()\n", + " return super().__sizeof__() + self.nbytes()\n" + ] + }, + { + "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 (G): 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", @@ -1908,12 +5234,198 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 64, "id": "5c8e359d", "metadata": { "lines_to_next_cell": 0 }, - "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()" ] @@ -1932,7 +5444,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 65, "id": "80f19869", "metadata": {}, "outputs": [], @@ -1953,7 +5465,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 66, "id": "6892597d", "metadata": {}, "outputs": [], @@ -1972,7 +5484,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 67, "id": "3eb1e1b0", "metadata": {}, "outputs": [], @@ -1997,12 +5509,49 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 68, "id": "0e89d251", "metadata": { "lines_to_next_cell": 2 }, - "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", @@ -2026,7 +5575,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 69, "id": "69456669", "metadata": { "lines_to_next_cell": 2 @@ -2070,12 +5619,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 70, "id": "70b3ece2", "metadata": { "lines_to_next_cell": 0 }, - "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", @@ -2103,10 +5664,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)" @@ -2126,7 +5698,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 72, "id": "ffa8da37", "metadata": { "lines_to_next_cell": 0 @@ -2153,7 +5725,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 73, "id": "11eeeabb", "metadata": { "lines_to_next_cell": 0 @@ -2190,10 +5762,50 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 74, "id": "5fe55a29", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_39/lib/python3.9/site-packages/torchinfo/torchinfo.py:477: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly. To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()\n", + " action_fn=lambda data: sys.getsizeof(data.storage()),\n", + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_39/lib/python3.9/site-packages/torch/storage.py:665: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly. To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()\n", + " return super().__sizeof__() + self.nbytes()\n" + ] + }, + { + "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 (G): 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", @@ -2222,7 +5834,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 75, "id": "e1ebbc70", "metadata": {}, "outputs": [], @@ -2245,10 +5857,496 @@ }, { "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: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_39/lib/python3.9/site-packages/pytorch_lightning/trainer/trainer.py:1789: UserWarning: MPS available but not used. Set `accelerator` and `devices` using `Trainer(accelerator='mps', devices=1)`.\n", + " rank_zero_warn(\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_39/lib/python3.9/site-packages/pytorch_lightning/trainer/trainer.py:1892: 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": "44936d415c7e4ad6b38cd97c733a90be", + "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", @@ -2269,12 +6367,49 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 77, "id": "887d7dad", "metadata": { "lines_to_next_cell": 2 }, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "03f177eef9fe4ed090eef15f0a005581", + "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", + " Test metric DataLoader 0\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", + " test_accuracy 0.8543599843978882\n", + " test_loss 1.1992340087890625\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n" + ] + }, + { + "data": { + "text/plain": [ + "[{'test_loss': 1.1992340087890625, 'test_accuracy': 0.8543599843978882}]" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "test_results = imdb_trainer.test(imdb_module, datamodule=imdb_dm)\n", "test_results" @@ -2294,7 +6429,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 78, "id": "055a9aeb", "metadata": {}, "outputs": [], @@ -2318,7 +6453,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 79, "id": "e3e1e181", "metadata": { "lines_to_next_cell": 0 @@ -2343,7 +6478,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 80, "id": "dd64350c", "metadata": { "lines_to_next_cell": 0 @@ -2367,7 +6502,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 81, "id": "0bf8b868", "metadata": {}, "outputs": [], @@ -2393,7 +6528,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 82, "id": "28256828", "metadata": { "lines_to_next_cell": 0 @@ -2415,7 +6550,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 83, "id": "a5945618", "metadata": { "lines_to_next_cell": 0 @@ -2458,12 +6593,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 84, "id": "74704884", "metadata": { "lines_to_next_cell": 0 }, - "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", @@ -2493,7 +6640,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 85, "id": "b1ecfca8", "metadata": { "lines_to_next_cell": 2 @@ -2539,7 +6686,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 86, "id": "5503cb3f", "metadata": {}, "outputs": [], @@ -2582,7 +6729,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 87, "id": "8b683641", "metadata": { "lines_to_next_cell": 0 @@ -2613,10 +6760,48 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 88, "id": "702aa8de", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_39/lib/python3.9/site-packages/torchinfo/torchinfo.py:477: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly. To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()\n", + " action_fn=lambda data: sys.getsizeof(data.storage()),\n", + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_39/lib/python3.9/site-packages/torch/storage.py:665: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly. To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()\n", + " return super().__sizeof__() + self.nbytes()\n" + ] + }, + { + "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 (M): 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", @@ -2637,7 +6822,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 89, "id": "e48aa272", "metadata": {}, "outputs": [], @@ -2648,12 +6833,350 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 90, "id": "143be7e8", "metadata": { "lines_to_next_cell": 0 }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_39/lib/python3.9/site-packages/pytorch_lightning/trainer/trainer.py:1789: UserWarning: MPS available but not used. Set `accelerator` and `devices` using `Trainer(accelerator='mps', devices=1)`.\n", + " rank_zero_warn(\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": "1ee0aabd8caf403c93b8c4ba0a1c2507", + "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", @@ -2674,10 +7197,47 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 91, "id": "9272e2ba", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "92a1cacbb1944d74b3f3c0670eb84b63", + "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", + " Test metric DataLoader 0\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", + " test_accuracy 0.8452399969100952\n", + " test_loss 0.7559056878089905\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n" + ] + }, + { + "data": { + "text/plain": [ + "[{'test_loss': 0.7559056878089905, 'test_accuracy': 0.8452399969100952}]" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "lstm_trainer.test(lstm_module, datamodule=imdb_seq_dm)" ] @@ -2692,12 +7252,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 92, "id": "5d9d387e", "metadata": { "lines_to_next_cell": 2 }, - "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", @@ -2712,7 +7293,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 93, "id": "7c6d1072", "metadata": { "lines_to_next_cell": 2 @@ -2740,7 +7321,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 94, "id": "8e2d1d5c", "metadata": {}, "outputs": [], @@ -2765,7 +7346,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 95, "id": "6f6d0e12", "metadata": {}, "outputs": [], @@ -2790,12 +7371,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 96, "id": "d3c961ec", "metadata": { "lines_to_next_cell": 2 }, - "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", @@ -2813,10 +7409,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", @@ -2835,7 +7442,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 98, "id": "55d921d7", "metadata": { "lines_to_next_cell": 0 @@ -2859,12 +7466,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 99, "id": "4e87eeb9", "metadata": { "lines_to_next_cell": 0 }, - "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])" @@ -2900,12 +7518,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 100, "id": "3689b318", "metadata": { "lines_to_next_cell": 0 }, - "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", @@ -2925,12 +7558,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 101, "id": "5633e521", "metadata": { "lines_to_next_cell": 0 }, - "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" @@ -2952,7 +7596,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 102, "id": "979a6066", "metadata": {}, "outputs": [], @@ -2989,7 +7633,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 103, "id": "3528f4e7", "metadata": {}, "outputs": [], @@ -3012,12 +7656,50 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 104, "id": "795c283e", "metadata": { "lines_to_next_cell": 0 }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_39/lib/python3.9/site-packages/torchinfo/torchinfo.py:477: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly. To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()\n", + " action_fn=lambda data: sys.getsizeof(data.storage()),\n", + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_39/lib/python3.9/site-packages/torch/storage.py:665: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly. To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()\n", + " return super().__sizeof__() + self.nbytes()\n" + ] + }, + { + "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 (M): 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", @@ -3038,7 +7720,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 105, "id": "31640121", "metadata": { "lines_to_next_cell": 0 @@ -3062,10 +7744,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", @@ -3086,7 +7778,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 107, "id": "0d04344c", "metadata": {}, "outputs": [], @@ -3109,12 +7801,1867 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 108, "id": "485d7bb1", "metadata": { "lines_to_next_cell": 2 }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "/Users/jonathantaylor/anaconda3/envs/islp_freeze_39/lib/python3.9/site-packages/pytorch_lightning/trainer/trainer.py:1789: UserWarning: MPS available but not used. Set `accelerator` and `devices` using `Trainer(accelerator='mps', devices=1)`.\n", + " rank_zero_warn(\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": "bf9eb739cc954760813987d94e79fb8e", + "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" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\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": "ce04cc5cab594022a6b0e9a1f429ba10", + "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": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\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": "a45ddcb60d7b4bd69dfaa5e0338d7dcb", + "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": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\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": "c95a6371f5af4aeaa0a58a5f5b85db44", + "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": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\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" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\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": "89e3e03d38994cf1a1093722c2c4fe1a", + "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": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\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": "951e5cbfbb804e779bbbaf4b4a351ae2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5d3d473df90f4dd3aeb829d52d35d641", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7395df14478d4bed859a3f9cf8ccbead", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ef61c7b225144a7398cff81780b0e60b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "404284c1c9ea41628cb9bb6f4d031cd3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b651d8b168ee452a98c397148c7d1aea", + "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": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7c66168b0e85424c8abe2446f7f9e5a9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6998335a07b341f39fd4ebf1c93d162f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "076763c8702042028a8d216e15fef774", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "abb0d6faecc24e059b3e68671dc38ad5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "140dcdd80e2443619f46d24a17ed9d50", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "991f4ae3b2b249848b57f5015f5fe6c7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "95da57cb36fb4ebaa0d52fa94d6c4b32", + "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": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5d6915797540439da8b0448c860eb604", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e5855d2022474bb7923ec7915138699b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "209f7ce81cd24ef2976c054769619f84", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1924729f28a84ff3b7c9c8607cea1de7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "58b7467b4a7c4b10aee2d9bf3eb3fafc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ce9b0241a7384110a1b0291f01f3780b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7ec8d539b2ab4f58beb3b5f49764fff3", + "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": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "41c8e961dac34415a4ccceb8babbcf01", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8ac4d97ce9634218bdf232cca63d6069", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ffea75eb7ccc4af3b66af673c485401b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "80c06a18bd4e4b159ff4f0bd1b333994", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "911f58a64ce24c9b8825fdd6372580eb", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "37e309ed15c34ebf9ad329024eda3c23", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "59a073d533f0447fa920155ad6e9aa1a", + "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": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5175feb3fd374cd89de5c62e3d3b1b08", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ce0ca0dae31c498ea244ccdcfae501e7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bd510768c59f427787f55d787ea8e5cc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "95dfb50b714949bf8e28d8bbe00736bf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "437d2e7134b24877afc41e5355fb686c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4fc6d6a6db814fcca6cdc78e63f3f816", + "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": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "45a341642e2d4080ad9554826fe775f0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b5a45975a73c4d3f9b6d19dc27d249f5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "742d6b44d2a14afba4b98a4e4ce75e2c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "60e2119e8ae348ab9368218e4fef8c7c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "aac8c13ba5864e6cb2d62a2c6a5dde86", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0022bae4698c4f52b7515abb1a444d4c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ff5051151de94de98de6be6b6ee5c6b6", + "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": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "38bf027d00494f90a40bb178fe6db007", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d6cf38392f8c448883140a325ca52878", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ae0806202fe441d68d48773578f252c2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2a788a24e8f843e18e6013d7d76d1041", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1b46aad0207543afad9d9ac4670605c2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0e90e2cf3add47c7958f4025508c0f40", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3750b847af554f3ebe96677e2d2580d1", + "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": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "dd50a1b812d04368968cf4c4ecf3f639", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a5c7d28ab7c44c0aae170b05a3c6e923", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c32ddfe9a7f44ee8a1485716dd209ca1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "47a99671fd634e1799addd33bfaca5ab", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "98482279444c4db9bc48fbfe02dfb7dc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a56dbc5229434698a43139dc4ff3a460", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b52732b1d1e94f46a1cd037b29d27ce0", + "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": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4f1264a1828b4d55b74f0dccd97919c5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "59bf88e571724091ab98f7258dbe4780", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "632942952df344ee98d2423705e060c5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "152694e1fe214fe899cbeba080d5fec7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "92e87ecd035e4a98af8940873c217a08", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5cfb6d3324224105bb51a11ee3610e99", + "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": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4b11d5fcedba4da68bec988d9c1af1a8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "39bf95953cd84ff1b5206301be0caba9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4507f5f3b42c4f79815e72a55cd57101", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c47d400fe5ac44098a50f94c59223d71", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8b580013d7f0447a96878fa0982eda94", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "49e3e8b33931437bb03110aacac4c11d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "82e34b2ab25a4d52bd58dd791fab350b", + "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": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0233c4562c014826845209456bb8d5f4", + "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", + " Test metric DataLoader 0\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", + " test_loss 0.6207807064056396\n", + " test_r2 0.41084879636764526\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n" + ] + }, + { + "data": { + "text/plain": [ + "[{'test_loss': 0.6207807064056396, 'test_r2': 0.41084879636764526}]" + ] + }, + "execution_count": 108, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "nyse_trainer = Trainer(deterministic=True,\n", " max_epochs=200,\n", @@ -3143,7 +9690,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 109, "id": "91d6633a", "metadata": {}, "outputs": [], @@ -3167,7 +9714,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 110, "id": "87137503", "metadata": {}, "outputs": [], @@ -3189,7 +9736,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 111, "id": "3cf09a55", "metadata": {}, "outputs": [], @@ -3208,7 +9755,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 112, "id": "930576f3", "metadata": {}, "outputs": [], @@ -3232,12 +9779,283 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 113, "id": "b9ae8d0e", "metadata": { "lines_to_next_cell": 0 }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\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 | NonLinearARModel | 705 \n", + "1 | loss | MSELoss | 0 \n", + "-------------------------------------------\n", + "705 Trainable params\n", + "0 Non-trainable params\n", + "705 Total params\n", + "0.003 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": "1e278bfc60e6404f98175752ac8f6482", + "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" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\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" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "IOPub message rate exceeded.\n", + "The Jupyter server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--ServerApp.iopub_msg_rate_limit`.\n", + "\n", + "Current values:\n", + "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", + "ServerApp.rate_limit_window=3.0 (secs)\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", + " Test metric DataLoader 0\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", + " test_loss 0.5648325681686401\n", + " test_r2 0.4639463424682617\n", + "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n" + ] + }, + { + "data": { + "text/plain": [ + "[{'test_loss': 0.5648325681686401, 'test_r2': 0.4639463424682617}]" + ] + }, + "execution_count": 113, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "nl_trainer = Trainer(deterministic=True,\n", " max_epochs=20,\n", @@ -3262,6 +10080,23 @@ "cell_metadata_filter": "-all", "main_language": "python", "notebook_metadata_filter": "-all" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.17" } }, "nbformat": 4, diff --git a/Ch13-multiple-lab.ipynb b/Ch13-multiple-lab.ipynb index fc9ef1c..65fb5bb 100644 --- a/Ch13-multiple-lab.ipynb +++ b/Ch13-multiple-lab.ipynb @@ -26,10 +26,10 @@ "id": "1f928b2d", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:19.844070Z", - "iopub.status.busy": "2023-07-26T05:18:19.843934Z", - "iopub.status.idle": "2023-07-26T05:18:20.995139Z", - "shell.execute_reply": "2023-07-26T05:18:20.994713Z" + "iopub.execute_input": "2023-07-26T10:52:21.791802Z", + "iopub.status.busy": "2023-07-26T10:52:21.791660Z", + "iopub.status.idle": "2023-07-26T10:52:23.360588Z", + "shell.execute_reply": "2023-07-26T10:52:23.359991Z" } }, "outputs": [], @@ -56,10 +56,10 @@ "id": "eb4b32aa", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:20.998019Z", - "iopub.status.busy": "2023-07-26T05:18:20.997705Z", - "iopub.status.idle": "2023-07-26T05:18:21.000088Z", - "shell.execute_reply": "2023-07-26T05:18:20.999729Z" + "iopub.execute_input": "2023-07-26T10:52:23.363356Z", + "iopub.status.busy": "2023-07-26T10:52:23.362843Z", + "iopub.status.idle": "2023-07-26T10:52:23.365980Z", + "shell.execute_reply": "2023-07-26T10:52:23.365438Z" }, "lines_to_next_cell": 2 }, @@ -95,10 +95,10 @@ "id": "e12ac0cd", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:21.002154Z", - "iopub.status.busy": "2023-07-26T05:18:21.001964Z", - "iopub.status.idle": "2023-07-26T05:18:21.004652Z", - "shell.execute_reply": "2023-07-26T05:18:21.004217Z" + "iopub.execute_input": "2023-07-26T10:52:23.368340Z", + "iopub.status.busy": "2023-07-26T10:52:23.368164Z", + "iopub.status.idle": "2023-07-26T10:52:23.371202Z", + "shell.execute_reply": "2023-07-26T10:52:23.370779Z" } }, "outputs": [], @@ -125,10 +125,10 @@ "id": "04d0f49e", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:21.006791Z", - "iopub.status.busy": "2023-07-26T05:18:21.006626Z", - "iopub.status.idle": "2023-07-26T05:18:21.011087Z", - "shell.execute_reply": "2023-07-26T05:18:21.010631Z" + "iopub.execute_input": "2023-07-26T10:52:23.373512Z", + "iopub.status.busy": "2023-07-26T10:52:23.373319Z", + "iopub.status.idle": "2023-07-26T10:52:23.378383Z", + "shell.execute_reply": "2023-07-26T10:52:23.377960Z" } }, "outputs": [ @@ -172,10 +172,10 @@ "id": "d1f0c695", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:21.013303Z", - "iopub.status.busy": "2023-07-26T05:18:21.013146Z", - "iopub.status.idle": "2023-07-26T05:18:21.040168Z", - "shell.execute_reply": "2023-07-26T05:18:21.039572Z" + "iopub.execute_input": "2023-07-26T10:52:23.380819Z", + "iopub.status.busy": "2023-07-26T10:52:23.380641Z", + "iopub.status.idle": "2023-07-26T10:52:23.408797Z", + "shell.execute_reply": "2023-07-26T10:52:23.408278Z" }, "lines_to_next_cell": 0 }, @@ -208,10 +208,10 @@ "id": "7a9594a0", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:21.042871Z", - "iopub.status.busy": "2023-07-26T05:18:21.042697Z", - "iopub.status.idle": "2023-07-26T05:18:21.053245Z", - "shell.execute_reply": "2023-07-26T05:18:21.052783Z" + "iopub.execute_input": "2023-07-26T10:52:23.411256Z", + "iopub.status.busy": "2023-07-26T10:52:23.411053Z", + "iopub.status.idle": "2023-07-26T10:52:23.422652Z", + "shell.execute_reply": "2023-07-26T10:52:23.422286Z" }, "lines_to_next_cell": 0 }, @@ -308,10 +308,10 @@ "id": "25f7fc5d", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:21.055393Z", - "iopub.status.busy": "2023-07-26T05:18:21.055224Z", - "iopub.status.idle": "2023-07-26T05:18:21.087295Z", - "shell.execute_reply": "2023-07-26T05:18:21.086103Z" + "iopub.execute_input": "2023-07-26T10:52:23.425157Z", + "iopub.status.busy": "2023-07-26T10:52:23.424798Z", + "iopub.status.idle": "2023-07-26T10:52:23.455752Z", + "shell.execute_reply": "2023-07-26T10:52:23.455052Z" }, "lines_to_next_cell": 0 }, @@ -420,10 +420,10 @@ "id": "369b5bd3", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:21.089602Z", - "iopub.status.busy": "2023-07-26T05:18:21.089466Z", - "iopub.status.idle": "2023-07-26T05:18:21.334785Z", - "shell.execute_reply": "2023-07-26T05:18:21.334139Z" + "iopub.execute_input": "2023-07-26T10:52:23.458631Z", + "iopub.status.busy": "2023-07-26T10:52:23.458434Z", + "iopub.status.idle": "2023-07-26T10:52:23.710141Z", + "shell.execute_reply": "2023-07-26T10:52:23.709635Z" } }, "outputs": [ @@ -476,10 +476,10 @@ "id": "9ce7a19f", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:21.337623Z", - "iopub.status.busy": "2023-07-26T05:18:21.337486Z", - "iopub.status.idle": "2023-07-26T05:18:21.381760Z", - "shell.execute_reply": "2023-07-26T05:18:21.381285Z" + "iopub.execute_input": "2023-07-26T10:52:23.713438Z", + "iopub.status.busy": "2023-07-26T10:52:23.713214Z", + "iopub.status.idle": "2023-07-26T10:52:23.754484Z", + "shell.execute_reply": "2023-07-26T10:52:23.754038Z" } }, "outputs": [ @@ -544,10 +544,10 @@ "id": "de6cffed", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:21.385154Z", - "iopub.status.busy": "2023-07-26T05:18:21.384811Z", - "iopub.status.idle": "2023-07-26T05:18:21.391013Z", - "shell.execute_reply": "2023-07-26T05:18:21.390441Z" + "iopub.execute_input": "2023-07-26T10:52:23.756665Z", + "iopub.status.busy": "2023-07-26T10:52:23.756493Z", + "iopub.status.idle": "2023-07-26T10:52:23.759438Z", + "shell.execute_reply": "2023-07-26T10:52:23.759028Z" }, "lines_to_next_cell": 2 }, @@ -583,10 +583,10 @@ "id": "0de71500", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:21.393254Z", - "iopub.status.busy": "2023-07-26T05:18:21.393106Z", - "iopub.status.idle": "2023-07-26T05:18:21.396315Z", - "shell.execute_reply": "2023-07-26T05:18:21.395885Z" + "iopub.execute_input": "2023-07-26T10:52:23.761459Z", + "iopub.status.busy": "2023-07-26T10:52:23.761287Z", + "iopub.status.idle": "2023-07-26T10:52:23.764317Z", + "shell.execute_reply": "2023-07-26T10:52:23.763952Z" } }, "outputs": [ @@ -625,10 +625,10 @@ "id": "f7e87bdb", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:21.398835Z", - "iopub.status.busy": "2023-07-26T05:18:21.398649Z", - "iopub.status.idle": "2023-07-26T05:18:21.442948Z", - "shell.execute_reply": "2023-07-26T05:18:21.442582Z" + "iopub.execute_input": "2023-07-26T10:52:23.766793Z", + "iopub.status.busy": "2023-07-26T10:52:23.766606Z", + "iopub.status.idle": "2023-07-26T10:52:23.810152Z", + "shell.execute_reply": "2023-07-26T10:52:23.809736Z" }, "lines_to_next_cell": 2 }, @@ -664,10 +664,10 @@ "id": "e88be376", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:21.445154Z", - "iopub.status.busy": "2023-07-26T05:18:21.445015Z", - "iopub.status.idle": "2023-07-26T05:18:21.448669Z", - "shell.execute_reply": "2023-07-26T05:18:21.448142Z" + "iopub.execute_input": "2023-07-26T10:52:23.812384Z", + "iopub.status.busy": "2023-07-26T10:52:23.812232Z", + "iopub.status.idle": "2023-07-26T10:52:23.815971Z", + "shell.execute_reply": "2023-07-26T10:52:23.815576Z" }, "lines_to_next_cell": 2 }, @@ -708,10 +708,10 @@ "id": "41149af6", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:21.450826Z", - "iopub.status.busy": "2023-07-26T05:18:21.450708Z", - "iopub.status.idle": "2023-07-26T05:18:21.454190Z", - "shell.execute_reply": "2023-07-26T05:18:21.453783Z" + "iopub.execute_input": "2023-07-26T10:52:23.817997Z", + "iopub.status.busy": "2023-07-26T10:52:23.817852Z", + "iopub.status.idle": "2023-07-26T10:52:23.821301Z", + "shell.execute_reply": "2023-07-26T10:52:23.820976Z" } }, "outputs": [ @@ -760,10 +760,10 @@ "id": "61aabda7", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:21.456352Z", - "iopub.status.busy": "2023-07-26T05:18:21.456221Z", - "iopub.status.idle": "2023-07-26T05:18:21.958936Z", - "shell.execute_reply": "2023-07-26T05:18:21.958451Z" + "iopub.execute_input": "2023-07-26T10:52:23.823367Z", + "iopub.status.busy": "2023-07-26T10:52:23.823190Z", + "iopub.status.idle": "2023-07-26T10:52:24.308715Z", + "shell.execute_reply": "2023-07-26T10:52:24.308222Z" }, "lines_to_next_cell": 2 }, @@ -820,10 +820,10 @@ "id": "cbcad4de", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:21.961206Z", - "iopub.status.busy": "2023-07-26T05:18:21.960995Z", - "iopub.status.idle": "2023-07-26T05:18:22.061061Z", - "shell.execute_reply": "2023-07-26T05:18:22.060588Z" + "iopub.execute_input": "2023-07-26T10:52:24.311170Z", + "iopub.status.busy": "2023-07-26T10:52:24.310960Z", + "iopub.status.idle": "2023-07-26T10:52:24.410742Z", + "shell.execute_reply": "2023-07-26T10:52:24.410212Z" } }, "outputs": [ @@ -861,10 +861,10 @@ "id": "b5842190", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:22.063984Z", - "iopub.status.busy": "2023-07-26T05:18:22.063716Z", - "iopub.status.idle": "2023-07-26T05:18:22.498224Z", - "shell.execute_reply": "2023-07-26T05:18:22.497832Z" + "iopub.execute_input": "2023-07-26T10:52:24.413638Z", + "iopub.status.busy": "2023-07-26T10:52:24.413455Z", + "iopub.status.idle": "2023-07-26T10:52:24.827343Z", + "shell.execute_reply": "2023-07-26T10:52:24.826609Z" } }, "outputs": [], @@ -890,10 +890,10 @@ "id": "7c9d8bed", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:22.501364Z", - "iopub.status.busy": "2023-07-26T05:18:22.501145Z", - "iopub.status.idle": "2023-07-26T05:18:22.506550Z", - "shell.execute_reply": "2023-07-26T05:18:22.504793Z" + "iopub.execute_input": "2023-07-26T10:52:24.830214Z", + "iopub.status.busy": "2023-07-26T10:52:24.830015Z", + "iopub.status.idle": "2023-07-26T10:52:24.834953Z", + "shell.execute_reply": "2023-07-26T10:52:24.834464Z" } }, "outputs": [ @@ -935,10 +935,10 @@ "id": "bfa39f7c", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:22.509383Z", - "iopub.status.busy": "2023-07-26T05:18:22.509219Z", - "iopub.status.idle": "2023-07-26T05:18:22.512714Z", - "shell.execute_reply": "2023-07-26T05:18:22.511931Z" + "iopub.execute_input": "2023-07-26T10:52:24.837627Z", + "iopub.status.busy": "2023-07-26T10:52:24.837419Z", + "iopub.status.idle": "2023-07-26T10:52:24.840834Z", + "shell.execute_reply": "2023-07-26T10:52:24.840316Z" }, "lines_to_next_cell": 0 }, @@ -979,10 +979,10 @@ "id": "70b69b47", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:22.515207Z", - "iopub.status.busy": "2023-07-26T05:18:22.515072Z", - "iopub.status.idle": "2023-07-26T05:18:22.518293Z", - "shell.execute_reply": "2023-07-26T05:18:22.517957Z" + "iopub.execute_input": "2023-07-26T10:52:24.843470Z", + "iopub.status.busy": "2023-07-26T10:52:24.843237Z", + "iopub.status.idle": "2023-07-26T10:52:24.846889Z", + "shell.execute_reply": "2023-07-26T10:52:24.846276Z" }, "lines_to_next_cell": 2 }, @@ -1029,10 +1029,10 @@ "id": "4c0ddea1", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:22.521202Z", - "iopub.status.busy": "2023-07-26T05:18:22.520998Z", - "iopub.status.idle": "2023-07-26T05:18:22.524429Z", - "shell.execute_reply": "2023-07-26T05:18:22.523980Z" + "iopub.execute_input": "2023-07-26T10:52:24.849388Z", + "iopub.status.busy": "2023-07-26T10:52:24.849238Z", + "iopub.status.idle": "2023-07-26T10:52:24.852847Z", + "shell.execute_reply": "2023-07-26T10:52:24.852354Z" } }, "outputs": [], @@ -1063,10 +1063,10 @@ "id": "0314eac9", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:22.526726Z", - "iopub.status.busy": "2023-07-26T05:18:22.526598Z", - "iopub.status.idle": "2023-07-26T05:18:22.818289Z", - "shell.execute_reply": "2023-07-26T05:18:22.816699Z" + "iopub.execute_input": "2023-07-26T10:52:24.855721Z", + "iopub.status.busy": "2023-07-26T10:52:24.855334Z", + "iopub.status.idle": "2023-07-26T10:52:25.156072Z", + "shell.execute_reply": "2023-07-26T10:52:25.155438Z" }, "lines_to_next_cell": 2 }, @@ -1113,10 +1113,10 @@ "id": "b59b8137", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:22.820822Z", - "iopub.status.busy": "2023-07-26T05:18:22.820643Z", - "iopub.status.idle": "2023-07-26T05:18:22.904147Z", - "shell.execute_reply": "2023-07-26T05:18:22.903628Z" + "iopub.execute_input": "2023-07-26T10:52:25.158998Z", + "iopub.status.busy": "2023-07-26T10:52:25.158769Z", + "iopub.status.idle": "2023-07-26T10:52:25.243020Z", + "shell.execute_reply": "2023-07-26T10:52:25.242512Z" }, "lines_to_next_cell": 2 }, @@ -1164,10 +1164,10 @@ "id": "96fb2f61", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:22.906635Z", - "iopub.status.busy": "2023-07-26T05:18:22.906449Z", - "iopub.status.idle": "2023-07-26T05:18:22.911110Z", - "shell.execute_reply": "2023-07-26T05:18:22.910655Z" + "iopub.execute_input": "2023-07-26T10:52:25.245359Z", + "iopub.status.busy": "2023-07-26T10:52:25.245172Z", + "iopub.status.idle": "2023-07-26T10:52:25.250139Z", + "shell.execute_reply": "2023-07-26T10:52:25.249644Z" }, "lines_to_next_cell": 2 }, @@ -1217,10 +1217,10 @@ "id": "fdc229fa", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:22.914821Z", - "iopub.status.busy": "2023-07-26T05:18:22.914646Z", - "iopub.status.idle": "2023-07-26T05:18:23.799918Z", - "shell.execute_reply": "2023-07-26T05:18:23.799169Z" + "iopub.execute_input": "2023-07-26T10:52:25.252510Z", + "iopub.status.busy": "2023-07-26T10:52:25.252319Z", + "iopub.status.idle": "2023-07-26T10:52:26.208474Z", + "shell.execute_reply": "2023-07-26T10:52:26.207894Z" }, "lines_to_next_cell": 2 }, @@ -1268,10 +1268,10 @@ "id": "e3894695", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:23.802625Z", - "iopub.status.busy": "2023-07-26T05:18:23.802497Z", - "iopub.status.idle": "2023-07-26T05:18:24.055142Z", - "shell.execute_reply": "2023-07-26T05:18:24.054759Z" + "iopub.execute_input": "2023-07-26T10:52:26.210995Z", + "iopub.status.busy": "2023-07-26T10:52:26.210826Z", + "iopub.status.idle": "2023-07-26T10:52:26.458716Z", + "shell.execute_reply": "2023-07-26T10:52:26.458144Z" }, "lines_to_next_cell": 0 }, @@ -1328,10 +1328,10 @@ "id": "3b7392cb", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:18:24.058084Z", - "iopub.status.busy": "2023-07-26T05:18:24.057792Z", - "iopub.status.idle": "2023-07-26T05:19:49.850383Z", - "shell.execute_reply": "2023-07-26T05:19:49.849836Z" + "iopub.execute_input": "2023-07-26T10:52:26.461754Z", + "iopub.status.busy": "2023-07-26T10:52:26.461349Z", + "iopub.status.idle": "2023-07-26T12:21:43.650925Z", + "shell.execute_reply": "2023-07-26T12:21:43.650584Z" } }, "outputs": [], @@ -1374,10 +1374,10 @@ "id": "cac15616", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:19:49.853395Z", - "iopub.status.busy": "2023-07-26T05:19:49.853240Z", - "iopub.status.idle": "2023-07-26T05:19:50.116177Z", - "shell.execute_reply": "2023-07-26T05:19:50.115410Z" + "iopub.execute_input": "2023-07-26T12:21:43.653105Z", + "iopub.status.busy": "2023-07-26T12:21:43.652856Z", + "iopub.status.idle": "2023-07-26T12:21:43.895651Z", + "shell.execute_reply": "2023-07-26T12:21:43.895292Z" } }, "outputs": [], @@ -1415,10 +1415,10 @@ "id": "9661eb10", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:19:50.118953Z", - "iopub.status.busy": "2023-07-26T05:19:50.118722Z", - "iopub.status.idle": "2023-07-26T05:19:50.122122Z", - "shell.execute_reply": "2023-07-26T05:19:50.121703Z" + "iopub.execute_input": "2023-07-26T12:21:43.897943Z", + "iopub.status.busy": "2023-07-26T12:21:43.897797Z", + "iopub.status.idle": "2023-07-26T12:21:43.901002Z", + "shell.execute_reply": "2023-07-26T12:21:43.900637Z" } }, "outputs": [ @@ -1470,10 +1470,10 @@ "id": "18ad4900", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:19:50.125992Z", - "iopub.status.busy": "2023-07-26T05:19:50.124866Z", - "iopub.status.idle": "2023-07-26T05:19:50.129615Z", - "shell.execute_reply": "2023-07-26T05:19:50.129295Z" + "iopub.execute_input": "2023-07-26T12:21:43.902778Z", + "iopub.status.busy": "2023-07-26T12:21:43.902684Z", + "iopub.status.idle": "2023-07-26T12:21:43.905535Z", + "shell.execute_reply": "2023-07-26T12:21:43.905228Z" } }, "outputs": [ @@ -1538,10 +1538,10 @@ "id": "28c276b6", "metadata": { "execution": { - "iopub.execute_input": "2023-07-26T05:19:50.132193Z", - "iopub.status.busy": "2023-07-26T05:19:50.132003Z", - "iopub.status.idle": "2023-07-26T05:19:50.220721Z", - "shell.execute_reply": "2023-07-26T05:19:50.220253Z" + "iopub.execute_input": "2023-07-26T12:21:43.907278Z", + "iopub.status.busy": "2023-07-26T12:21:43.907150Z", + "iopub.status.idle": "2023-07-26T12:21:43.988689Z", + "shell.execute_reply": "2023-07-26T12:21:43.988352Z" }, "lines_to_next_cell": 0 },