diff --git "a/test.ipynb" "b/test.ipynb" new file mode 100644--- /dev/null +++ "b/test.ipynb" @@ -0,0 +1,35985 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "18e11bfc", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import torch as t\n", + "from datasets import load_dataset" + ] + }, + { + "cell_type": "markdown", + "id": "52ee59a9", + "metadata": {}, + "source": [ + "## Loading the hf data to pytorch dataset\n", + "* pytorch dataset is a wrapper of tuples\n", + "* load_dataset is a wrapper around dict" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "119adc87", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9dceefe92dfd4163b390dc85e2718c8b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Resolving data files: 0%| | 0/119 [00:00", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mUnidentifiedImageError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[46]\u001b[39m\u001b[32m, line 12\u001b[39m\n\u001b[32m 9\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33m\"\u001b[39m\u001b[33m-\u001b[39m\u001b[33m\"\u001b[39m * \u001b[32m40\u001b[39m)\n\u001b[32m 11\u001b[39m \u001b[38;5;66;03m# Using tqdm so you can track progress across the 40,000+ images\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m12\u001b[39m \u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43midx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mitem\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43menumerate\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtest\u001b[49m\u001b[43m)\u001b[49m\u001b[43m:\u001b[49m\n\u001b[32m 13\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mtry\u001b[39;49;00m\u001b[43m:\u001b[49m\n\u001b[32m 14\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m# Accessing the image size triggers the file reading\u001b[39;49;00m\n\u001b[32m 15\u001b[39m \u001b[43m \u001b[49m\u001b[43mshape\u001b[49m\u001b[43m \u001b[49m\u001b[43m=\u001b[49m\u001b[43m \u001b[49m\u001b[43mitem\u001b[49m\u001b[43m[\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mimage\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m.\u001b[49m\u001b[43msize\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/lab_env/lib/python3.13/site-packages/datasets/arrow_dataset.py:2483\u001b[39m, in \u001b[36mDataset.__iter__\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 2481\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(pa_subtable.num_rows):\n\u001b[32m 2482\u001b[39m pa_subtable_ex = pa_subtable.slice(i, \u001b[32m1\u001b[39m)\n\u001b[32m-> \u001b[39m\u001b[32m2483\u001b[39m formatted_output = \u001b[43mformat_table\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 2484\u001b[39m \u001b[43m \u001b[49m\u001b[43mpa_subtable_ex\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 2485\u001b[39m \u001b[43m \u001b[49m\u001b[32;43m0\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 2486\u001b[39m \u001b[43m \u001b[49m\u001b[43mformatter\u001b[49m\u001b[43m=\u001b[49m\u001b[43mformatter\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 2487\u001b[39m \u001b[43m \u001b[49m\u001b[43mformat_columns\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_format_columns\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 2488\u001b[39m \u001b[43m \u001b[49m\u001b[43moutput_all_columns\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_output_all_columns\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 2489\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 2490\u001b[39m \u001b[38;5;28;01myield\u001b[39;00m formatted_output\n\u001b[32m 2491\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/lab_env/lib/python3.13/site-packages/datasets/formatting/formatting.py:666\u001b[39m, in \u001b[36mformat_table\u001b[39m\u001b[34m(table, key, formatter, format_columns, output_all_columns)\u001b[39m\n\u001b[32m 664\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 665\u001b[39m pa_table_to_format = pa_table.drop(col \u001b[38;5;28;01mfor\u001b[39;00m col \u001b[38;5;129;01min\u001b[39;00m pa_table.column_names \u001b[38;5;28;01mif\u001b[39;00m col \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m format_columns)\n\u001b[32m--> \u001b[39m\u001b[32m666\u001b[39m formatted_output = \u001b[43mformatter\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpa_table_to_format\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mquery_type\u001b[49m\u001b[43m=\u001b[49m\u001b[43mquery_type\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 667\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m output_all_columns:\n\u001b[32m 668\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(formatted_output, MutableMapping):\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/lab_env/lib/python3.13/site-packages/datasets/formatting/formatting.py:411\u001b[39m, in \u001b[36mFormatter.__call__\u001b[39m\u001b[34m(self, pa_table, query_type)\u001b[39m\n\u001b[32m 409\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, pa_table: pa.Table, query_type: \u001b[38;5;28mstr\u001b[39m) -> Union[RowFormat, ColumnFormat, BatchFormat]:\n\u001b[32m 410\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m query_type == \u001b[33m\"\u001b[39m\u001b[33mrow\u001b[39m\u001b[33m\"\u001b[39m:\n\u001b[32m--> \u001b[39m\u001b[32m411\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mformat_row\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpa_table\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 412\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m query_type == \u001b[33m\"\u001b[39m\u001b[33mcolumn\u001b[39m\u001b[33m\"\u001b[39m:\n\u001b[32m 413\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m.format_column(pa_table)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/lab_env/lib/python3.13/site-packages/datasets/formatting/torch_formatter.py:253\u001b[39m, in \u001b[36mTorchFormatter.format_row\u001b[39m\u001b[34m(self, pa_table)\u001b[39m\n\u001b[32m 251\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mformat_row\u001b[39m(\u001b[38;5;28mself\u001b[39m, pa_table: pa.Table) -> Mapping:\n\u001b[32m 252\u001b[39m row = \u001b[38;5;28mself\u001b[39m.numpy_arrow_extractor().extract_row(pa_table)\n\u001b[32m--> \u001b[39m\u001b[32m253\u001b[39m row = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mpython_features_decoder\u001b[49m\u001b[43m.\u001b[49m\u001b[43mdecode_row\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrow\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 254\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m.recursive_tensorize(row)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/lab_env/lib/python3.13/site-packages/datasets/formatting/formatting.py:224\u001b[39m, in \u001b[36mPythonFeaturesDecoder.decode_row\u001b[39m\u001b[34m(self, row)\u001b[39m\n\u001b[32m 223\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mdecode_row\u001b[39m(\u001b[38;5;28mself\u001b[39m, row: \u001b[38;5;28mdict\u001b[39m) -> \u001b[38;5;28mdict\u001b[39m:\n\u001b[32m--> \u001b[39m\u001b[32m224\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mfeatures\u001b[49m\u001b[43m.\u001b[49m\u001b[43mdecode_example\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrow\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtoken_per_repo_id\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mtoken_per_repo_id\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.features \u001b[38;5;28;01melse\u001b[39;00m row\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/lab_env/lib/python3.13/site-packages/datasets/features/features.py:2111\u001b[39m, in \u001b[36mFeatures.decode_example\u001b[39m\u001b[34m(self, example, token_per_repo_id)\u001b[39m\n\u001b[32m 2096\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mdecode_example\u001b[39m(\u001b[38;5;28mself\u001b[39m, example: \u001b[38;5;28mdict\u001b[39m, token_per_repo_id: Optional[\u001b[38;5;28mdict\u001b[39m[\u001b[38;5;28mstr\u001b[39m, Union[\u001b[38;5;28mstr\u001b[39m, \u001b[38;5;28mbool\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m]]] = \u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[32m 2097\u001b[39m \u001b[38;5;250m \u001b[39m\u001b[33;03m\"\"\"Decode example with custom feature decoding.\u001b[39;00m\n\u001b[32m 2098\u001b[39m \n\u001b[32m 2099\u001b[39m \u001b[33;03m Args:\u001b[39;00m\n\u001b[32m (...)\u001b[39m\u001b[32m 2107\u001b[39m \u001b[33;03m `dict[str, Any]`\u001b[39;00m\n\u001b[32m 2108\u001b[39m \u001b[33;03m \"\"\"\u001b[39;00m\n\u001b[32m 2110\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[32m-> \u001b[39m\u001b[32m2111\u001b[39m column_name: \u001b[43mdecode_nested_example\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfeature\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtoken_per_repo_id\u001b[49m\u001b[43m=\u001b[49m\u001b[43mtoken_per_repo_id\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 2112\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._column_requires_decoding[column_name]\n\u001b[32m 2113\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m value\n\u001b[32m 2114\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m column_name, (feature, value) \u001b[38;5;129;01min\u001b[39;00m zip_dict(\n\u001b[32m 2115\u001b[39m {key: value \u001b[38;5;28;01mfor\u001b[39;00m key, value \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m.items() \u001b[38;5;28;01mif\u001b[39;00m key \u001b[38;5;129;01min\u001b[39;00m example}, example\n\u001b[32m 2116\u001b[39m )\n\u001b[32m 2117\u001b[39m }\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/lab_env/lib/python3.13/site-packages/datasets/features/features.py:1419\u001b[39m, in \u001b[36mdecode_nested_example\u001b[39m\u001b[34m(schema, obj, token_per_repo_id)\u001b[39m\n\u001b[32m 1416\u001b[39m \u001b[38;5;66;03m# Object with special decoding:\u001b[39;00m\n\u001b[32m 1417\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(schema, \u001b[33m\"\u001b[39m\u001b[33mdecode_example\u001b[39m\u001b[33m\"\u001b[39m) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mgetattr\u001b[39m(schema, \u001b[33m\"\u001b[39m\u001b[33mdecode\u001b[39m\u001b[33m\"\u001b[39m, \u001b[38;5;28;01mTrue\u001b[39;00m):\n\u001b[32m 1418\u001b[39m \u001b[38;5;66;03m# we pass the token to read and decode files from private repositories in streaming mode\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m1419\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mschema\u001b[49m\u001b[43m.\u001b[49m\u001b[43mdecode_example\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobj\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtoken_per_repo_id\u001b[49m\u001b[43m=\u001b[49m\u001b[43mtoken_per_repo_id\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mif\u001b[39;00m obj \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m 1420\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m obj\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/lab_env/lib/python3.13/site-packages/datasets/features/image.py:192\u001b[39m, in \u001b[36mImage.decode_example\u001b[39m\u001b[34m(self, value, token_per_repo_id)\u001b[39m\n\u001b[32m 190\u001b[39m image = PIL.Image.open(bytes_)\n\u001b[32m 191\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m192\u001b[39m image = \u001b[43mPIL\u001b[49m\u001b[43m.\u001b[49m\u001b[43mImage\u001b[49m\u001b[43m.\u001b[49m\u001b[43mopen\u001b[49m\u001b[43m(\u001b[49m\u001b[43mBytesIO\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbytes_\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 193\u001b[39m image.load() \u001b[38;5;66;03m# to avoid \"Too many open files\" errors\u001b[39;00m\n\u001b[32m 194\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m image.getexif().get(PIL.Image.ExifTags.Base.Orientation) \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/lab_env/lib/python3.13/site-packages/PIL/Image.py:3560\u001b[39m, in \u001b[36mopen\u001b[39m\u001b[34m(fp, mode, formats)\u001b[39m\n\u001b[32m 3558\u001b[39m warnings.warn(message)\n\u001b[32m 3559\u001b[39m msg = \u001b[33m\"\u001b[39m\u001b[33mcannot identify image file \u001b[39m\u001b[38;5;132;01m%r\u001b[39;00m\u001b[33m\"\u001b[39m % (filename \u001b[38;5;28;01mif\u001b[39;00m filename \u001b[38;5;28;01melse\u001b[39;00m fp)\n\u001b[32m-> \u001b[39m\u001b[32m3560\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m UnidentifiedImageError(msg)\n", + "\u001b[31mUnidentifiedImageError\u001b[39m: cannot identify image file <_io.BytesIO object at 0x377cfaed0>" + ] + } + ], + "source": [ + "import warnings\n", + "from PIL import UnidentifiedImageError\n", + "from tqdm.auto import tqdm\n", + "\n", + "# 1. Silences the 'Corrupt EXIF data' warning cluttering your output\n", + "warnings.filterwarnings(\"ignore\", category=UserWarning, module=\"PIL.TiffImagePlugin\")\n", + "\n", + "print(f\"{'Index':<8} | {'Shape':<20} | {'Label'}\")\n", + "print(\"-\" * 40)\n", + "\n", + "# Using tqdm so you can track progress across the 40,000+ images\n", + "for idx, item in enumerate(test):\n", + " try:\n", + " # Accessing the image size triggers the file reading\n", + " shape = item[\"image\"].size()\n", + " label = item[\"label\"]\n", + " print(f\"{idx:<8} | {str(shape):<20} | {label}\")\n", + " \n", + " except (UnidentifiedImageError, OSError) as e:\n", + " # This catches the \"cannot identify image file\" error\n", + " print(f\"{idx:<8} | !!! CORRUPT IMAGE !!! | {item.get('label', '??')}\")\n", + " \n", + " except Exception as e:\n", + " # General safety net for any other weird errors\n", + " print(f\"{idx:<8} | Error: {type(e).__name__} | Label: {item.get('label', '??')}\")\n", + "\n", + " # Safety break so you don't print 40k lines at once\n", + " # if idx >= 100: \n", + " # print(\"\\nStopping at 100 images for preview...\")\n", + " # break" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "4cb4da2c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Device: mps\n" + ] + } + ], + "source": [ + "device = t.device(\"cuda\" if t.cuda.is_available() else\n", + " \"mps\" if t.backends.mps.is_available() else\n", + " \"cpu\")\n", + "\n", + "print(f\"Device: {device}\")" + ] + }, + { + "cell_type": "markdown", + "id": "29aea2e7", + "metadata": {}, + "source": [ + "## Defining the Model" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "4e00ed32", + "metadata": {}, + "outputs": [], + "source": [ + "import torch.nn as nn\n", + "\n", + "class BottleneckBlock(nn.Module):\n", + " expansion = 4\n", + "\n", + " def __init__(self, in_channels, mid_channels, stride=1):\n", + " super(BottleneckBlock, self).__init__()\n", + " \n", + " out_channels = mid_channels * self.expansion\n", + "\n", + " \n", + " self.conv1 = nn.Conv2d(in_channels, mid_channels, kernel_size=1, bias=False)\n", + " self.bn1 = nn.BatchNorm2d(mid_channels)\n", + " \n", + " self.conv2 = nn.Conv2d(mid_channels, mid_channels, kernel_size=3, stride=stride, padding=1, bias=False)\n", + " self.bn2 = nn.BatchNorm2d(mid_channels)\n", + " \n", + " self.conv3 = nn.Conv2d(mid_channels, out_channels, kernel_size=1, bias=False)\n", + " self.bn3 = nn.BatchNorm2d(out_channels)\n", + " \n", + " self.relu = nn.ReLU(inplace=True)\n", + "\n", + " self.shortcut = nn.Sequential()\n", + "\n", + " if stride != 1 or in_channels != out_channels:\n", + " self.shortcut = nn.Sequential(\n", + " nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),\n", + " nn.BatchNorm2d(out_channels)\n", + " )\n", + "\n", + " def forward(self, x):\n", + " identity = x\n", + "\n", + " out = self.conv1(x)\n", + " out = self.bn1(out)\n", + " out = self.relu(out)\n", + "\n", + " out = self.conv2(out)\n", + " out = self.bn2(out)\n", + " out = self.relu(out)\n", + "\n", + " out = self.conv3(out)\n", + " out = self.bn3(out)\n", + " \n", + " identity = self.shortcut(identity)\n", + "\n", + " out += identity\n", + " out = self.relu(out)\n", + "\n", + " return out \n", + " \n", + "\n", + "class ResNet50(nn.Module):\n", + " def __init__(self, num_classes=16, channels_img=3):\n", + " super(ResNet50, self).__init__()\n", + " \n", + " self.in_channels = 64\n", + "\n", + " self.conv1 = nn.Conv2d(channels_img, 64, kernel_size=7, stride=2, padding=3, bias=False)\n", + " self.bn1 = nn.BatchNorm2d(64)\n", + " self.relu = nn.ReLU(inplace=True)\n", + " self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n", + "\n", + " self.stage1 = self._make_layer(mid_channels=64, num_blocks=3, stride=1)\n", + " \n", + " self.stage2 = self._make_layer(mid_channels=128, num_blocks=4, stride=2)\n", + " \n", + " self.stage3 = self._make_layer(mid_channels=256, num_blocks=6, stride=2)\n", + " \n", + " self.stage4 = self._make_layer(mid_channels=512, num_blocks=3, stride=2)\n", + "\n", + " self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n", + "\n", + " self.fc = nn.Linear(512 * 4, num_classes) # 512*4 = 2048\n", + "\n", + " def _make_layer(self, mid_channels, num_blocks, stride):\n", + " layers = []\n", + " \n", + " layers.append(BottleneckBlock(self.in_channels, mid_channels, stride))\n", + " \n", + " self.in_channels = mid_channels * 4\n", + "\n", + " for _ in range(num_blocks - 1):\n", + " layers.append(BottleneckBlock(self.in_channels, mid_channels, stride=1))\n", + "\n", + " return nn.Sequential(*layers)\n", + "\n", + " def forward(self, x):\n", + " # Stem\n", + " x = self.conv1(x)\n", + " x = self.bn1(x)\n", + " x = self.relu(x)\n", + " x = self.maxpool(x)\n", + "\n", + " # Stages\n", + " x = self.stage1(x)\n", + " x = self.stage2(x)\n", + " x = self.stage3(x)\n", + " x = self.stage4(x)\n", + "\n", + " # Head\n", + " x = self.avgpool(x)\n", + " x = t.flatten(x, 1) # Flatten from (N, 2048, 1, 1) to (N, 2048)\n", + " x = self.fc(x)\n", + "\n", + " return x \n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "44c64c24", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mps\n" + ] + } + ], + "source": [ + "device = t.device(\"cuda\" if t.cuda.is_available() else\n", + " \"mps\" if t.backends.mps.is_available() else\n", + " \"cpu\")\n", + "print(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "a6c18e07", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ResNet50(\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", + " (stage1): Sequential(\n", + " (0): BottleneckBlock(\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", + " (shortcut): 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): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " (2): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " )\n", + " (stage2): Sequential(\n", + " (0): BottleneckBlock(\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", + " (shortcut): 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): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " (2): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " (3): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " )\n", + " (stage3): Sequential(\n", + " (0): BottleneckBlock(\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", + " (shortcut): 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): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " (2): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " (3): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " (4): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " (5): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " )\n", + " (stage4): Sequential(\n", + " (0): BottleneckBlock(\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", + " (shortcut): 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): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " (2): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " )\n", + " (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n", + " (fc): Linear(in_features=2048, out_features=16, bias=True)\n", + ")\n" + ] + } + ], + "source": [ + "resnet50 = ResNet50().to(device)\n", + "print(resnet50)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "db985cee", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "layer_name: conv1.weight, params_shape: torch.Size([64, 3, 7, 7])\n", + "layer_name: bn1.weight, params_shape: torch.Size([64])\n", + "layer_name: bn1.bias, params_shape: torch.Size([64])\n", + "layer_name: stage1.0.conv1.weight, params_shape: torch.Size([64, 64, 1, 1])\n", + "layer_name: stage1.0.bn1.weight, params_shape: torch.Size([64])\n", + "layer_name: stage1.0.bn1.bias, params_shape: torch.Size([64])\n", + "layer_name: stage1.0.conv2.weight, params_shape: torch.Size([64, 64, 3, 3])\n", + "layer_name: stage1.0.bn2.weight, params_shape: torch.Size([64])\n", + "layer_name: stage1.0.bn2.bias, params_shape: torch.Size([64])\n", + "layer_name: stage1.0.conv3.weight, params_shape: torch.Size([256, 64, 1, 1])\n", + "layer_name: stage1.0.bn3.weight, params_shape: torch.Size([256])\n", + "layer_name: stage1.0.bn3.bias, params_shape: torch.Size([256])\n", + "layer_name: stage1.0.shortcut.0.weight, params_shape: torch.Size([256, 64, 1, 1])\n", + "layer_name: stage1.0.shortcut.1.weight, params_shape: torch.Size([256])\n", + "layer_name: stage1.0.shortcut.1.bias, params_shape: torch.Size([256])\n", + "layer_name: stage1.1.conv1.weight, params_shape: torch.Size([64, 256, 1, 1])\n", + "layer_name: stage1.1.bn1.weight, params_shape: torch.Size([64])\n", + "layer_name: stage1.1.bn1.bias, params_shape: torch.Size([64])\n", + "layer_name: stage1.1.conv2.weight, params_shape: torch.Size([64, 64, 3, 3])\n", + "layer_name: stage1.1.bn2.weight, params_shape: torch.Size([64])\n", + "layer_name: stage1.1.bn2.bias, params_shape: torch.Size([64])\n", + "layer_name: stage1.1.conv3.weight, params_shape: torch.Size([256, 64, 1, 1])\n", + "layer_name: stage1.1.bn3.weight, params_shape: torch.Size([256])\n", + "layer_name: stage1.1.bn3.bias, params_shape: torch.Size([256])\n", + "layer_name: stage1.2.conv1.weight, params_shape: torch.Size([64, 256, 1, 1])\n", + "layer_name: stage1.2.bn1.weight, params_shape: torch.Size([64])\n", + "layer_name: stage1.2.bn1.bias, params_shape: torch.Size([64])\n", + "layer_name: stage1.2.conv2.weight, params_shape: torch.Size([64, 64, 3, 3])\n", + "layer_name: stage1.2.bn2.weight, params_shape: torch.Size([64])\n", + "layer_name: stage1.2.bn2.bias, params_shape: torch.Size([64])\n", + "layer_name: stage1.2.conv3.weight, params_shape: torch.Size([256, 64, 1, 1])\n", + "layer_name: stage1.2.bn3.weight, params_shape: torch.Size([256])\n", + "layer_name: stage1.2.bn3.bias, params_shape: torch.Size([256])\n", + "layer_name: stage2.0.conv1.weight, params_shape: torch.Size([128, 256, 1, 1])\n", + "layer_name: stage2.0.bn1.weight, params_shape: torch.Size([128])\n", + "layer_name: stage2.0.bn1.bias, params_shape: torch.Size([128])\n", + "layer_name: stage2.0.conv2.weight, params_shape: torch.Size([128, 128, 3, 3])\n", + "layer_name: stage2.0.bn2.weight, params_shape: torch.Size([128])\n", + "layer_name: stage2.0.bn2.bias, params_shape: torch.Size([128])\n", + "layer_name: stage2.0.conv3.weight, params_shape: torch.Size([512, 128, 1, 1])\n", + "layer_name: stage2.0.bn3.weight, params_shape: torch.Size([512])\n", + "layer_name: stage2.0.bn3.bias, params_shape: torch.Size([512])\n", + "layer_name: stage2.0.shortcut.0.weight, params_shape: torch.Size([512, 256, 1, 1])\n", + "layer_name: stage2.0.shortcut.1.weight, params_shape: torch.Size([512])\n", + "layer_name: stage2.0.shortcut.1.bias, params_shape: torch.Size([512])\n", + "layer_name: stage2.1.conv1.weight, params_shape: torch.Size([128, 512, 1, 1])\n", + "layer_name: stage2.1.bn1.weight, params_shape: torch.Size([128])\n", + "layer_name: stage2.1.bn1.bias, params_shape: torch.Size([128])\n", + "layer_name: stage2.1.conv2.weight, params_shape: torch.Size([128, 128, 3, 3])\n", + "layer_name: stage2.1.bn2.weight, params_shape: torch.Size([128])\n", + "layer_name: stage2.1.bn2.bias, params_shape: torch.Size([128])\n", + "layer_name: stage2.1.conv3.weight, params_shape: torch.Size([512, 128, 1, 1])\n", + "layer_name: stage2.1.bn3.weight, params_shape: torch.Size([512])\n", + "layer_name: stage2.1.bn3.bias, params_shape: torch.Size([512])\n", + "layer_name: stage2.2.conv1.weight, params_shape: torch.Size([128, 512, 1, 1])\n", + "layer_name: stage2.2.bn1.weight, params_shape: torch.Size([128])\n", + "layer_name: stage2.2.bn1.bias, params_shape: torch.Size([128])\n", + "layer_name: stage2.2.conv2.weight, params_shape: torch.Size([128, 128, 3, 3])\n", + "layer_name: stage2.2.bn2.weight, params_shape: torch.Size([128])\n", + "layer_name: stage2.2.bn2.bias, params_shape: torch.Size([128])\n", + "layer_name: stage2.2.conv3.weight, params_shape: torch.Size([512, 128, 1, 1])\n", + "layer_name: stage2.2.bn3.weight, params_shape: torch.Size([512])\n", + "layer_name: stage2.2.bn3.bias, params_shape: torch.Size([512])\n", + "layer_name: stage2.3.conv1.weight, params_shape: torch.Size([128, 512, 1, 1])\n", + "layer_name: stage2.3.bn1.weight, params_shape: torch.Size([128])\n", + "layer_name: stage2.3.bn1.bias, params_shape: torch.Size([128])\n", + "layer_name: stage2.3.conv2.weight, params_shape: torch.Size([128, 128, 3, 3])\n", + "layer_name: stage2.3.bn2.weight, params_shape: torch.Size([128])\n", + "layer_name: stage2.3.bn2.bias, params_shape: torch.Size([128])\n", + "layer_name: stage2.3.conv3.weight, params_shape: torch.Size([512, 128, 1, 1])\n", + "layer_name: stage2.3.bn3.weight, params_shape: torch.Size([512])\n", + "layer_name: stage2.3.bn3.bias, params_shape: torch.Size([512])\n", + "layer_name: stage3.0.conv1.weight, params_shape: torch.Size([256, 512, 1, 1])\n", + "layer_name: stage3.0.bn1.weight, params_shape: torch.Size([256])\n", + "layer_name: stage3.0.bn1.bias, params_shape: torch.Size([256])\n", + "layer_name: stage3.0.conv2.weight, params_shape: torch.Size([256, 256, 3, 3])\n", + "layer_name: stage3.0.bn2.weight, params_shape: torch.Size([256])\n", + "layer_name: stage3.0.bn2.bias, params_shape: torch.Size([256])\n", + "layer_name: stage3.0.conv3.weight, params_shape: torch.Size([1024, 256, 1, 1])\n", + "layer_name: stage3.0.bn3.weight, params_shape: torch.Size([1024])\n", + "layer_name: stage3.0.bn3.bias, params_shape: torch.Size([1024])\n", + "layer_name: stage3.0.shortcut.0.weight, params_shape: torch.Size([1024, 512, 1, 1])\n", + "layer_name: stage3.0.shortcut.1.weight, params_shape: torch.Size([1024])\n", + "layer_name: stage3.0.shortcut.1.bias, params_shape: torch.Size([1024])\n", + "layer_name: stage3.1.conv1.weight, params_shape: torch.Size([256, 1024, 1, 1])\n", + "layer_name: stage3.1.bn1.weight, params_shape: torch.Size([256])\n", + "layer_name: stage3.1.bn1.bias, params_shape: torch.Size([256])\n", + "layer_name: stage3.1.conv2.weight, params_shape: torch.Size([256, 256, 3, 3])\n", + "layer_name: stage3.1.bn2.weight, params_shape: torch.Size([256])\n", + "layer_name: stage3.1.bn2.bias, params_shape: torch.Size([256])\n", + "layer_name: stage3.1.conv3.weight, params_shape: torch.Size([1024, 256, 1, 1])\n", + "layer_name: stage3.1.bn3.weight, params_shape: torch.Size([1024])\n", + "layer_name: stage3.1.bn3.bias, params_shape: torch.Size([1024])\n", + "layer_name: stage3.2.conv1.weight, params_shape: torch.Size([256, 1024, 1, 1])\n", + "layer_name: stage3.2.bn1.weight, params_shape: torch.Size([256])\n", + "layer_name: stage3.2.bn1.bias, params_shape: torch.Size([256])\n", + "layer_name: stage3.2.conv2.weight, params_shape: torch.Size([256, 256, 3, 3])\n", + "layer_name: stage3.2.bn2.weight, params_shape: torch.Size([256])\n", + "layer_name: stage3.2.bn2.bias, params_shape: torch.Size([256])\n", + "layer_name: stage3.2.conv3.weight, params_shape: torch.Size([1024, 256, 1, 1])\n", + "layer_name: stage3.2.bn3.weight, params_shape: torch.Size([1024])\n", + "layer_name: stage3.2.bn3.bias, params_shape: torch.Size([1024])\n", + "layer_name: stage3.3.conv1.weight, params_shape: torch.Size([256, 1024, 1, 1])\n", + "layer_name: stage3.3.bn1.weight, params_shape: torch.Size([256])\n", + "layer_name: stage3.3.bn1.bias, params_shape: torch.Size([256])\n", + "layer_name: stage3.3.conv2.weight, params_shape: torch.Size([256, 256, 3, 3])\n", + "layer_name: stage3.3.bn2.weight, params_shape: torch.Size([256])\n", + "layer_name: stage3.3.bn2.bias, params_shape: torch.Size([256])\n", + "layer_name: stage3.3.conv3.weight, params_shape: torch.Size([1024, 256, 1, 1])\n", + "layer_name: stage3.3.bn3.weight, params_shape: torch.Size([1024])\n", + "layer_name: stage3.3.bn3.bias, params_shape: torch.Size([1024])\n", + "layer_name: stage3.4.conv1.weight, params_shape: torch.Size([256, 1024, 1, 1])\n", + "layer_name: stage3.4.bn1.weight, params_shape: torch.Size([256])\n", + "layer_name: stage3.4.bn1.bias, params_shape: torch.Size([256])\n", + "layer_name: stage3.4.conv2.weight, params_shape: torch.Size([256, 256, 3, 3])\n", + "layer_name: stage3.4.bn2.weight, params_shape: torch.Size([256])\n", + "layer_name: stage3.4.bn2.bias, params_shape: torch.Size([256])\n", + "layer_name: stage3.4.conv3.weight, params_shape: torch.Size([1024, 256, 1, 1])\n", + "layer_name: stage3.4.bn3.weight, params_shape: torch.Size([1024])\n", + "layer_name: stage3.4.bn3.bias, params_shape: torch.Size([1024])\n", + "layer_name: stage3.5.conv1.weight, params_shape: torch.Size([256, 1024, 1, 1])\n", + "layer_name: stage3.5.bn1.weight, params_shape: torch.Size([256])\n", + "layer_name: stage3.5.bn1.bias, params_shape: torch.Size([256])\n", + "layer_name: stage3.5.conv2.weight, params_shape: torch.Size([256, 256, 3, 3])\n", + "layer_name: stage3.5.bn2.weight, params_shape: torch.Size([256])\n", + "layer_name: stage3.5.bn2.bias, params_shape: torch.Size([256])\n", + "layer_name: stage3.5.conv3.weight, params_shape: torch.Size([1024, 256, 1, 1])\n", + "layer_name: stage3.5.bn3.weight, params_shape: torch.Size([1024])\n", + "layer_name: stage3.5.bn3.bias, params_shape: torch.Size([1024])\n", + "layer_name: stage4.0.conv1.weight, params_shape: torch.Size([512, 1024, 1, 1])\n", + "layer_name: stage4.0.bn1.weight, params_shape: torch.Size([512])\n", + "layer_name: stage4.0.bn1.bias, params_shape: torch.Size([512])\n", + "layer_name: stage4.0.conv2.weight, params_shape: torch.Size([512, 512, 3, 3])\n", + "layer_name: stage4.0.bn2.weight, params_shape: torch.Size([512])\n", + "layer_name: stage4.0.bn2.bias, params_shape: torch.Size([512])\n", + "layer_name: stage4.0.conv3.weight, params_shape: torch.Size([2048, 512, 1, 1])\n", + "layer_name: stage4.0.bn3.weight, params_shape: torch.Size([2048])\n", + "layer_name: stage4.0.bn3.bias, params_shape: torch.Size([2048])\n", + "layer_name: stage4.0.shortcut.0.weight, params_shape: torch.Size([2048, 1024, 1, 1])\n", + "layer_name: stage4.0.shortcut.1.weight, params_shape: torch.Size([2048])\n", + "layer_name: stage4.0.shortcut.1.bias, params_shape: torch.Size([2048])\n", + "layer_name: stage4.1.conv1.weight, params_shape: torch.Size([512, 2048, 1, 1])\n", + "layer_name: stage4.1.bn1.weight, params_shape: torch.Size([512])\n", + "layer_name: stage4.1.bn1.bias, params_shape: torch.Size([512])\n", + "layer_name: stage4.1.conv2.weight, params_shape: torch.Size([512, 512, 3, 3])\n", + "layer_name: stage4.1.bn2.weight, params_shape: torch.Size([512])\n", + "layer_name: stage4.1.bn2.bias, params_shape: torch.Size([512])\n", + "layer_name: stage4.1.conv3.weight, params_shape: torch.Size([2048, 512, 1, 1])\n", + "layer_name: stage4.1.bn3.weight, params_shape: torch.Size([2048])\n", + "layer_name: stage4.1.bn3.bias, params_shape: torch.Size([2048])\n", + "layer_name: stage4.2.conv1.weight, params_shape: torch.Size([512, 2048, 1, 1])\n", + "layer_name: stage4.2.bn1.weight, params_shape: torch.Size([512])\n", + "layer_name: stage4.2.bn1.bias, params_shape: torch.Size([512])\n", + "layer_name: stage4.2.conv2.weight, params_shape: torch.Size([512, 512, 3, 3])\n", + "layer_name: stage4.2.bn2.weight, params_shape: torch.Size([512])\n", + "layer_name: stage4.2.bn2.bias, params_shape: torch.Size([512])\n", + "layer_name: stage4.2.conv3.weight, params_shape: torch.Size([2048, 512, 1, 1])\n", + "layer_name: stage4.2.bn3.weight, params_shape: torch.Size([2048])\n", + "layer_name: stage4.2.bn3.bias, params_shape: torch.Size([2048])\n", + "layer_name: fc.weight, params_shape: torch.Size([16, 2048])\n", + "layer_name: fc.bias, params_shape: torch.Size([16])\n" + ] + } + ], + "source": [ + "for layer in resnet50.named_parameters():\n", + " print(f\"layer_name: {layer[0]}, params_shape: {layer[1].shape}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "eff57243", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ResNet50(\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", + " (stage1): Sequential(\n", + " (0): BottleneckBlock(\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", + " (shortcut): 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): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " (2): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " )\n", + " (stage2): Sequential(\n", + " (0): BottleneckBlock(\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", + " (shortcut): 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): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " (2): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " (3): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " )\n", + " (stage3): Sequential(\n", + " (0): BottleneckBlock(\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", + " (shortcut): 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): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " (2): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " (3): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " (4): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " (5): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " )\n", + " (stage4): Sequential(\n", + " (0): BottleneckBlock(\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", + " (shortcut): 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): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " (2): BottleneckBlock(\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", + " (shortcut): Sequential()\n", + " )\n", + " )\n", + " (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n", + " (fc): Linear(in_features=2048, out_features=16, bias=True)\n", + ")\n" + ] + } + ], + "source": [ + "print(resnet50)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ce8b5ce6", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "lab_env", + "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.13.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}