ResNet.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNMhZ48Y1SuYhiG4DrU8QU8",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/wuyi010/model/blob/main/ResNet.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MD-cW-z_NoDr"
      },
      "outputs": [],
      "source": [
        "from functools import partial\n",
        "from typing import Any, Callable, List, Optional, Type, Union\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "from torch import Tensor\n",
        "\n",
        "from ..transforms._presets import ImageClassification\n",
        "from ..utils import _log_api_usage_once\n",
        "from ._api import register_model, Weights, WeightsEnum\n",
        "from ._meta import _IMAGENET_CATEGORIES\n",
        "from ._utils import _ovewrite_named_param, handle_legacy_interface\n",
        "\n",
        "\n",
        "__all__ = [\n",
        "    \"ResNet\",\n",
        "    \"ResNet18_Weights\",\n",
        "    \"ResNet34_Weights\",\n",
        "    \"ResNet50_Weights\",\n",
        "    \"ResNet101_Weights\",\n",
        "    \"ResNet152_Weights\",\n",
        "    \"ResNeXt50_32X4D_Weights\",\n",
        "    \"ResNeXt101_32X8D_Weights\",\n",
        "    \"ResNeXt101_64X4D_Weights\",\n",
        "    \"Wide_ResNet50_2_Weights\",\n",
        "    \"Wide_ResNet101_2_Weights\",\n",
        "    \"resnet18\",\n",
        "    \"resnet34\",\n",
        "    \"resnet50\",\n",
        "    \"resnet101\",\n",
        "    \"resnet152\",\n",
        "    \"resnext50_32x4d\",\n",
        "    \"resnext101_32x8d\",\n",
        "    \"resnext101_64x4d\",\n",
        "    \"wide_resnet50_2\",\n",
        "    \"wide_resnet101_2\",\n",
        "]\n",
        "\n",
        "\n",
        "def conv3x3(in_planes: int, out_planes: int, stride: int = 1, groups: int = 1, dilation: int = 1) -> nn.Conv2d:\n",
        "    \"\"\"3x3 convolution with padding\"\"\"\n",
        "    return nn.Conv2d(\n",
        "        in_planes,\n",
        "        out_planes,\n",
        "        kernel_size=3,\n",
        "        stride=stride,\n",
        "        padding=dilation,\n",
        "        groups=groups,\n",
        "        bias=False,\n",
        "        dilation=dilation,\n",
        "    )\n",
        "\n",
        "\n",
        "def conv1x1(in_planes: int, out_planes: int, stride: int = 1) -> nn.Conv2d:\n",
        "    \"\"\"1x1 convolution\"\"\"\n",
        "    return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)\n",
        "\n",
        "\n",
        "class BasicBlock(nn.Module):\n",
        "    expansion: int = 1\n",
        "\n",
        "    def __init__(\n",
        "        self,\n",
        "        inplanes: int,\n",
        "        planes: int,\n",
        "        stride: int = 1,\n",
        "        downsample: Optional[nn.Module] = None,\n",
        "        groups: int = 1,\n",
        "        base_width: int = 64,\n",
        "        dilation: int = 1,\n",
        "        norm_layer: Optional[Callable[..., nn.Module]] = None,\n",
        "    ) -> None:\n",
        "        super().__init__()\n",
        "        if norm_layer is None:\n",
        "            norm_layer = nn.BatchNorm2d\n",
        "        if groups != 1 or base_width != 64:\n",
        "            raise ValueError(\"BasicBlock only supports groups=1 and base_width=64\")\n",
        "        if dilation > 1:\n",
        "            raise NotImplementedError(\"Dilation > 1 not supported in BasicBlock\")\n",
        "        # Both self.conv1 and self.downsample layers downsample the input when stride != 1\n",
        "        self.conv1 = conv3x3(inplanes, planes, stride)\n",
        "        self.bn1 = norm_layer(planes)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "        self.conv2 = conv3x3(planes, planes)\n",
        "        self.bn2 = norm_layer(planes)\n",
        "        self.downsample = downsample\n",
        "        self.stride = stride\n",
        "\n",
        "    def forward(self, x: Tensor) -> Tensor:\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",
        "\n",
        "        if self.downsample is not None:\n",
        "            identity = self.downsample(x)\n",
        "\n",
        "        out += identity\n",
        "        out = self.relu(out)\n",
        "\n",
        "        return out\n",
        "\n",
        "\n",
        "class Bottleneck(nn.Module):\n",
        "    # Bottleneck in torchvision places the stride for downsampling at 3x3 convolution(self.conv2)\n",
        "    # while original implementation places the stride at the first 1x1 convolution(self.conv1)\n",
        "    # according to \"Deep residual learning for image recognition\" https://arxiv.org/abs/1512.03385.\n",
        "    # This variant is also known as ResNet V1.5 and improves accuracy according to\n",
        "    # https://ngc.nvidia.com/catalog/model-scripts/nvidia:resnet_50_v1_5_for_pytorch.\n",
        "\n",
        "    expansion: int = 4\n",
        "\n",
        "    def __init__(\n",
        "        self,\n",
        "        inplanes: int,\n",
        "        planes: int,\n",
        "        stride: int = 1,\n",
        "        downsample: Optional[nn.Module] = None,\n",
        "        groups: int = 1,\n",
        "        base_width: int = 64,\n",
        "        dilation: int = 1,\n",
        "        norm_layer: Optional[Callable[..., nn.Module]] = None,\n",
        "    ) -> None:\n",
        "        super().__init__()\n",
        "        if norm_layer is None:\n",
        "            norm_layer = nn.BatchNorm2d\n",
        "        width = int(planes * (base_width / 64.0)) * groups\n",
        "        # Both self.conv2 and self.downsample layers downsample the input when stride != 1\n",
        "        self.conv1 = conv1x1(inplanes, width)\n",
        "        self.bn1 = norm_layer(width)\n",
        "        self.conv2 = conv3x3(width, width, stride, groups, dilation)\n",
        "        self.bn2 = norm_layer(width)\n",
        "        self.conv3 = conv1x1(width, planes * self.expansion)\n",
        "        self.bn3 = norm_layer(planes * self.expansion)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "        self.downsample = downsample\n",
        "        self.stride = stride\n",
        "\n",
        "    def forward(self, x: Tensor) -> Tensor:\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",
        "        if self.downsample is not None:\n",
        "            identity = self.downsample(x)\n",
        "\n",
        "        out += identity\n",
        "        out = self.relu(out)\n",
        "\n",
        "        return out\n",
        "\n",
        "\n",
        "class ResNet(nn.Module):\n",
        "    def __init__(\n",
        "        self,\n",
        "        block: Type[Union[BasicBlock, Bottleneck]],\n",
        "        layers: List[int],\n",
        "        num_classes: int = 1000,\n",
        "        zero_init_residual: bool = False,\n",
        "        groups: int = 1,\n",
        "        width_per_group: int = 64,\n",
        "        replace_stride_with_dilation: Optional[List[bool]] = None,\n",
        "        norm_layer: Optional[Callable[..., nn.Module]] = None,\n",
        "    ) -> None:\n",
        "        super().__init__()\n",
        "        _log_api_usage_once(self)\n",
        "        if norm_layer is None:\n",
        "            norm_layer = nn.BatchNorm2d\n",
        "        self._norm_layer = norm_layer\n",
        "\n",
        "        self.inplanes = 64\n",
        "        self.dilation = 1\n",
        "        if replace_stride_with_dilation is None:\n",
        "            # each element in the tuple indicates if we should replace\n",
        "            # the 2x2 stride with a dilated convolution instead\n",
        "            replace_stride_with_dilation = [False, False, False]\n",
        "        if len(replace_stride_with_dilation) != 3:\n",
        "            raise ValueError(\n",
        "                \"replace_stride_with_dilation should be None \"\n",
        "                f\"or a 3-element tuple, got {replace_stride_with_dilation}\"\n",
        "            )\n",
        "        self.groups = groups\n",
        "        self.base_width = width_per_group\n",
        "        self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3, bias=False)\n",
        "        self.bn1 = norm_layer(self.inplanes)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n",
        "        self.layer1 = self._make_layer(block, 64, layers[0])\n",
        "        self.layer2 = self._make_layer(block, 128, layers[1], stride=2, dilate=replace_stride_with_dilation[0])\n",
        "        self.layer3 = self._make_layer(block, 256, layers[2], stride=2, dilate=replace_stride_with_dilation[1])\n",
        "        self.layer4 = self._make_layer(block, 512, layers[3], stride=2, dilate=replace_stride_with_dilation[2])\n",
        "        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n",
        "        self.fc = nn.Linear(512 * block.expansion, num_classes)\n",
        "\n",
        "        for m in self.modules():\n",
        "            if isinstance(m, nn.Conv2d):\n",
        "                nn.init.kaiming_normal_(m.weight, mode=\"fan_out\", nonlinearity=\"relu\")\n",
        "            elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):\n",
        "                nn.init.constant_(m.weight, 1)\n",
        "                nn.init.constant_(m.bias, 0)\n",
        "\n",
        "        # Zero-initialize the last BN in each residual branch,\n",
        "        # so that the residual branch starts with zeros, and each residual block behaves like an identity.\n",
        "        # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677\n",
        "        if zero_init_residual:\n",
        "            for m in self.modules():\n",
        "                if isinstance(m, Bottleneck) and m.bn3.weight is not None:\n",
        "                    nn.init.constant_(m.bn3.weight, 0)  # type: ignore[arg-type]\n",
        "                elif isinstance(m, BasicBlock) and m.bn2.weight is not None:\n",
        "                    nn.init.constant_(m.bn2.weight, 0)  # type: ignore[arg-type]\n",
        "\n",
        "    def _make_layer(\n",
        "        self,\n",
        "        block: Type[Union[BasicBlock, Bottleneck]],\n",
        "        planes: int,\n",
        "        blocks: int,\n",
        "        stride: int = 1,\n",
        "        dilate: bool = False,\n",
        "    ) -> nn.Sequential:\n",
        "        norm_layer = self._norm_layer\n",
        "        downsample = None\n",
        "        previous_dilation = self.dilation\n",
        "        if dilate:\n",
        "            self.dilation *= stride\n",
        "            stride = 1\n",
        "        if stride != 1 or self.inplanes != planes * block.expansion:\n",
        "            downsample = nn.Sequential(\n",
        "                conv1x1(self.inplanes, planes * block.expansion, stride),\n",
        "                norm_layer(planes * block.expansion),\n",
        "            )\n",
        "\n",
        "        layers = []\n",
        "        layers.append(\n",
        "            block(\n",
        "                self.inplanes, planes, stride, downsample, self.groups, self.base_width, previous_dilation, norm_layer\n",
        "            )\n",
        "        )\n",
        "        self.inplanes = planes * block.expansion\n",
        "        for _ in range(1, blocks):\n",
        "            layers.append(\n",
        "                block(\n",
        "                    self.inplanes,\n",
        "                    planes,\n",
        "                    groups=self.groups,\n",
        "                    base_width=self.base_width,\n",
        "                    dilation=self.dilation,\n",
        "                    norm_layer=norm_layer,\n",
        "                )\n",
        "            )\n",
        "\n",
        "        return nn.Sequential(*layers)\n",
        "\n",
        "    def _forward_impl(self, x: Tensor) -> Tensor:\n",
        "        # See note [TorchScript super()]\n",
        "        x = self.conv1(x)\n",
        "        x = self.bn1(x)\n",
        "        x = self.relu(x)\n",
        "        x = self.maxpool(x)\n",
        "\n",
        "        x = self.layer1(x)\n",
        "        x = self.layer2(x)\n",
        "        x = self.layer3(x)\n",
        "        x = self.layer4(x)\n",
        "\n",
        "        x = self.avgpool(x)\n",
        "        x = torch.flatten(x, 1)\n",
        "        x = self.fc(x)\n",
        "\n",
        "        return x\n",
        "\n",
        "    def forward(self, x: Tensor) -> Tensor:\n",
        "        return self._forward_impl(x)\n",
        "\n",
        "\n",
        "def _resnet(\n",
        "    block: Type[Union[BasicBlock, Bottleneck]],\n",
        "    layers: List[int],\n",
        "    weights: Optional[WeightsEnum],\n",
        "    progress: bool,\n",
        "    **kwargs: Any,\n",
        ") -> ResNet:\n",
        "    if weights is not None:\n",
        "        _ovewrite_named_param(kwargs, \"num_classes\", len(weights.meta[\"categories\"]))\n",
        "\n",
        "    model = ResNet(block, layers, **kwargs)\n",
        "\n",
        "    if weights is not None:\n",
        "        model.load_state_dict(weights.get_state_dict(progress=progress, check_hash=True))\n",
        "\n",
        "    return model\n",
        "\n",
        "\n",
        "_COMMON_META = {\n",
        "    \"min_size\": (1, 1),\n",
        "    \"categories\": _IMAGENET_CATEGORIES,\n",
        "}\n",
        "\n",
        "\n",
        "class ResNet18_Weights(WeightsEnum):\n",
        "    IMAGENET1K_V1 = Weights(\n",
        "        url=\"https://download.pytorch.org/models/resnet18-f37072fd.pth\",\n",
        "        transforms=partial(ImageClassification, crop_size=224),\n",
        "        meta={\n",
        "            **_COMMON_META,\n",
        "            \"num_params\": 11689512,\n",
        "            \"recipe\": \"https://github.com/pytorch/vision/tree/main/references/classification#resnet\",\n",
        "            \"_metrics\": {\n",
        "                \"ImageNet-1K\": {\n",
        "                    \"acc@1\": 69.758,\n",
        "                    \"acc@5\": 89.078,\n",
        "                }\n",
        "            },\n",
        "            \"_ops\": 1.814,\n",
        "            \"_file_size\": 44.661,\n",
        "            \"_docs\": \"\"\"These weights reproduce closely the results of the paper using a simple training recipe.\"\"\",\n",
        "        },\n",
        "    )\n",
        "    DEFAULT = IMAGENET1K_V1\n",
        "\n",
        "\n",
        "class ResNet34_Weights(WeightsEnum):\n",
        "    IMAGENET1K_V1 = Weights(\n",
        "        url=\"https://download.pytorch.org/models/resnet34-b627a593.pth\",\n",
        "        transforms=partial(ImageClassification, crop_size=224),\n",
        "        meta={\n",
        "            **_COMMON_META,\n",
        "            \"num_params\": 21797672,\n",
        "            \"recipe\": \"https://github.com/pytorch/vision/tree/main/references/classification#resnet\",\n",
        "            \"_metrics\": {\n",
        "                \"ImageNet-1K\": {\n",
        "                    \"acc@1\": 73.314,\n",
        "                    \"acc@5\": 91.420,\n",
        "                }\n",
        "            },\n",
        "            \"_ops\": 3.664,\n",
        "            \"_file_size\": 83.275,\n",
        "            \"_docs\": \"\"\"These weights reproduce closely the results of the paper using a simple training recipe.\"\"\",\n",
        "        },\n",
        "    )\n",
        "    DEFAULT = IMAGENET1K_V1\n",
        "\n",
        "\n",
        "class ResNet50_Weights(WeightsEnum):\n",
        "    IMAGENET1K_V1 = Weights(\n",
        "        url=\"https://download.pytorch.org/models/resnet50-0676ba61.pth\",\n",
        "        transforms=partial(ImageClassification, crop_size=224),\n",
        "        meta={\n",
        "            **_COMMON_META,\n",
        "            \"num_params\": 25557032,\n",
        "            \"recipe\": \"https://github.com/pytorch/vision/tree/main/references/classification#resnet\",\n",
        "            \"_metrics\": {\n",
        "                \"ImageNet-1K\": {\n",
        "                    \"acc@1\": 76.130,\n",
        "                    \"acc@5\": 92.862,\n",
        "                }\n",
        "            },\n",
        "            \"_ops\": 4.089,\n",
        "            \"_file_size\": 97.781,\n",
        "            \"_docs\": \"\"\"These weights reproduce closely the results of the paper using a simple training recipe.\"\"\",\n",
        "        },\n",
        "    )\n",
        "    IMAGENET1K_V2 = Weights(\n",
        "        url=\"https://download.pytorch.org/models/resnet50-11ad3fa6.pth\",\n",
        "        transforms=partial(ImageClassification, crop_size=224, resize_size=232),\n",
        "        meta={\n",
        "            **_COMMON_META,\n",
        "            \"num_params\": 25557032,\n",
        "            \"recipe\": \"https://github.com/pytorch/vision/issues/3995#issuecomment-1013906621\",\n",
        "            \"_metrics\": {\n",
        "                \"ImageNet-1K\": {\n",
        "                    \"acc@1\": 80.858,\n",
        "                    \"acc@5\": 95.434,\n",
        "                }\n",
        "            },\n",
        "            \"_ops\": 4.089,\n",
        "            \"_file_size\": 97.79,\n",
        "            \"_docs\": \"\"\"\n",
        "                These weights improve upon the results of the original paper by using TorchVision's `new training recipe\n",
        "                <https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/>`_.\n",
        "            \"\"\",\n",
        "        },\n",
        "    )\n",
        "    DEFAULT = IMAGENET1K_V2\n",
        "\n",
        "\n",
        "class ResNet101_Weights(WeightsEnum):\n",
        "    IMAGENET1K_V1 = Weights(\n",
        "        url=\"https://download.pytorch.org/models/resnet101-63fe2227.pth\",\n",
        "        transforms=partial(ImageClassification, crop_size=224),\n",
        "        meta={\n",
        "            **_COMMON_META,\n",
        "            \"num_params\": 44549160,\n",
        "            \"recipe\": \"https://github.com/pytorch/vision/tree/main/references/classification#resnet\",\n",
        "            \"_metrics\": {\n",
        "                \"ImageNet-1K\": {\n",
        "                    \"acc@1\": 77.374,\n",
        "                    \"acc@5\": 93.546,\n",
        "                }\n",
        "            },\n",
        "            \"_ops\": 7.801,\n",
        "            \"_file_size\": 170.511,\n",
        "            \"_docs\": \"\"\"These weights reproduce closely the results of the paper using a simple training recipe.\"\"\",\n",
        "        },\n",
        "    )\n",
        "    IMAGENET1K_V2 = Weights(\n",
        "        url=\"https://download.pytorch.org/models/resnet101-cd907fc2.pth\",\n",
        "        transforms=partial(ImageClassification, crop_size=224, resize_size=232),\n",
        "        meta={\n",
        "            **_COMMON_META,\n",
        "            \"num_params\": 44549160,\n",
        "            \"recipe\": \"https://github.com/pytorch/vision/issues/3995#new-recipe\",\n",
        "            \"_metrics\": {\n",
        "                \"ImageNet-1K\": {\n",
        "                    \"acc@1\": 81.886,\n",
        "                    \"acc@5\": 95.780,\n",
        "                }\n",
        "            },\n",
        "            \"_ops\": 7.801,\n",
        "            \"_file_size\": 170.53,\n",
        "            \"_docs\": \"\"\"\n",
        "                These weights improve upon the results of the original paper by using TorchVision's `new training recipe\n",
        "                <https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/>`_.\n",
        "            \"\"\",\n",
        "        },\n",
        "    )\n",
        "    DEFAULT = IMAGENET1K_V2\n",
        "\n",
        "\n",
        "class ResNet152_Weights(WeightsEnum):\n",
        "    IMAGENET1K_V1 = Weights(\n",
        "        url=\"https://download.pytorch.org/models/resnet152-394f9c45.pth\",\n",
        "        transforms=partial(ImageClassification, crop_size=224),\n",
        "        meta={\n",
        "            **_COMMON_META,\n",
        "            \"num_params\": 60192808,\n",
        "            \"recipe\": \"https://github.com/pytorch/vision/tree/main/references/classification#resnet\",\n",
        "            \"_metrics\": {\n",
        "                \"ImageNet-1K\": {\n",
        "                    \"acc@1\": 78.312,\n",
        "                    \"acc@5\": 94.046,\n",
        "                }\n",
        "            },\n",
        "            \"_ops\": 11.514,\n",
        "            \"_file_size\": 230.434,\n",
        "            \"_docs\": \"\"\"These weights reproduce closely the results of the paper using a simple training recipe.\"\"\",\n",
        "        },\n",
        "    )\n",
        "    IMAGENET1K_V2 = Weights(\n",
        "        url=\"https://download.pytorch.org/models/resnet152-f82ba261.pth\",\n",
        "        transforms=partial(ImageClassification, crop_size=224, resize_size=232),\n",
        "        meta={\n",
        "            **_COMMON_META,\n",
        "            \"num_params\": 60192808,\n",
        "            \"recipe\": \"https://github.com/pytorch/vision/issues/3995#new-recipe\",\n",
        "            \"_metrics\": {\n",
        "                \"ImageNet-1K\": {\n",
        "                    \"acc@1\": 82.284,\n",
        "                    \"acc@5\": 96.002,\n",
        "                }\n",
        "            },\n",
        "            \"_ops\": 11.514,\n",
        "            \"_file_size\": 230.474,\n",
        "            \"_docs\": \"\"\"\n",
        "                These weights improve upon the results of the original paper by using TorchVision's `new training recipe\n",
        "                <https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/>`_.\n",
        "            \"\"\",\n",
        "        },\n",
        "    )\n",
        "    DEFAULT = IMAGENET1K_V2\n",
        "\n",
        "\n",
        "class ResNeXt50_32X4D_Weights(WeightsEnum):\n",
        "    IMAGENET1K_V1 = Weights(\n",
        "        url=\"https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth\",\n",
        "        transforms=partial(ImageClassification, crop_size=224),\n",
        "        meta={\n",
        "            **_COMMON_META,\n",
        "            \"num_params\": 25028904,\n",
        "            \"recipe\": \"https://github.com/pytorch/vision/tree/main/references/classification#resnext\",\n",
        "            \"_metrics\": {\n",
        "                \"ImageNet-1K\": {\n",
        "                    \"acc@1\": 77.618,\n",
        "                    \"acc@5\": 93.698,\n",
        "                }\n",
        "            },\n",
        "            \"_ops\": 4.23,\n",
        "            \"_file_size\": 95.789,\n",
        "            \"_docs\": \"\"\"These weights reproduce closely the results of the paper using a simple training recipe.\"\"\",\n",
        "        },\n",
        "    )\n",
        "    IMAGENET1K_V2 = Weights(\n",
        "        url=\"https://download.pytorch.org/models/resnext50_32x4d-1a0047aa.pth\",\n",
        "        transforms=partial(ImageClassification, crop_size=224, resize_size=232),\n",
        "        meta={\n",
        "            **_COMMON_META,\n",
        "            \"num_params\": 25028904,\n",
        "            \"recipe\": \"https://github.com/pytorch/vision/issues/3995#new-recipe\",\n",
        "            \"_metrics\": {\n",
        "                \"ImageNet-1K\": {\n",
        "                    \"acc@1\": 81.198,\n",
        "                    \"acc@5\": 95.340,\n",
        "                }\n",
        "            },\n",
        "            \"_ops\": 4.23,\n",
        "            \"_file_size\": 95.833,\n",
        "            \"_docs\": \"\"\"\n",
        "                These weights improve upon the results of the original paper by using TorchVision's `new training recipe\n",
        "                <https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/>`_.\n",
        "            \"\"\",\n",
        "        },\n",
        "    )\n",
        "    DEFAULT = IMAGENET1K_V2\n",
        "\n",
        "\n",
        "class ResNeXt101_32X8D_Weights(WeightsEnum):\n",
        "    IMAGENET1K_V1 = Weights(\n",
        "        url=\"https://download.pytorch.org/models/resnext101_32x8d-8ba56ff5.pth\",\n",
        "        transforms=partial(ImageClassification, crop_size=224),\n",
        "        meta={\n",
        "            **_COMMON_META,\n",
        "            \"num_params\": 88791336,\n",
        "            \"recipe\": \"https://github.com/pytorch/vision/tree/main/references/classification#resnext\",\n",
        "            \"_metrics\": {\n",
        "                \"ImageNet-1K\": {\n",
        "                    \"acc@1\": 79.312,\n",
        "                    \"acc@5\": 94.526,\n",
        "                }\n",
        "            },\n",
        "            \"_ops\": 16.414,\n",
        "            \"_file_size\": 339.586,\n",
        "            \"_docs\": \"\"\"These weights reproduce closely the results of the paper using a simple training recipe.\"\"\",\n",
        "        },\n",
        "    )\n",
        "    IMAGENET1K_V2 = Weights(\n",
        "        url=\"https://download.pytorch.org/models/resnext101_32x8d-110c445d.pth\",\n",
        "        transforms=partial(ImageClassification, crop_size=224, resize_size=232),\n",
        "        meta={\n",
        "            **_COMMON_META,\n",
        "            \"num_params\": 88791336,\n",
        "            \"recipe\": \"https://github.com/pytorch/vision/issues/3995#new-recipe-with-fixres\",\n",
        "            \"_metrics\": {\n",
        "                \"ImageNet-1K\": {\n",
        "                    \"acc@1\": 82.834,\n",
        "                    \"acc@5\": 96.228,\n",
        "                }\n",
        "            },\n",
        "            \"_ops\": 16.414,\n",
        "            \"_file_size\": 339.673,\n",
        "            \"_docs\": \"\"\"\n",
        "                These weights improve upon the results of the original paper by using TorchVision's `new training recipe\n",
        "                <https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/>`_.\n",
        "            \"\"\",\n",
        "        },\n",
        "    )\n",
        "    DEFAULT = IMAGENET1K_V2\n",
        "\n",
        "\n",
        "class ResNeXt101_64X4D_Weights(WeightsEnum):\n",
        "    IMAGENET1K_V1 = Weights(\n",
        "        url=\"https://download.pytorch.org/models/resnext101_64x4d-173b62eb.pth\",\n",
        "        transforms=partial(ImageClassification, crop_size=224, resize_size=232),\n",
        "        meta={\n",
        "            **_COMMON_META,\n",
        "            \"num_params\": 83455272,\n",
        "            \"recipe\": \"https://github.com/pytorch/vision/pull/5935\",\n",
        "            \"_metrics\": {\n",
        "                \"ImageNet-1K\": {\n",
        "                    \"acc@1\": 83.246,\n",
        "                    \"acc@5\": 96.454,\n",
        "                }\n",
        "            },\n",
        "            \"_ops\": 15.46,\n",
        "            \"_file_size\": 319.318,\n",
        "            \"_docs\": \"\"\"\n",
        "                These weights were trained from scratch by using TorchVision's `new training recipe\n",
        "                <https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/>`_.\n",
        "            \"\"\",\n",
        "        },\n",
        "    )\n",
        "    DEFAULT = IMAGENET1K_V1\n",
        "\n",
        "\n",
        "class Wide_ResNet50_2_Weights(WeightsEnum):\n",
        "    IMAGENET1K_V1 = Weights(\n",
        "        url=\"https://download.pytorch.org/models/wide_resnet50_2-95faca4d.pth\",\n",
        "        transforms=partial(ImageClassification, crop_size=224),\n",
        "        meta={\n",
        "            **_COMMON_META,\n",
        "            \"num_params\": 68883240,\n",
        "            \"recipe\": \"https://github.com/pytorch/vision/pull/912#issue-445437439\",\n",
        "            \"_metrics\": {\n",
        "                \"ImageNet-1K\": {\n",
        "                    \"acc@1\": 78.468,\n",
        "                    \"acc@5\": 94.086,\n",
        "                }\n",
        "            },\n",
        "            \"_ops\": 11.398,\n",
        "            \"_file_size\": 131.82,\n",
        "            \"_docs\": \"\"\"These weights reproduce closely the results of the paper using a simple training recipe.\"\"\",\n",
        "        },\n",
        "    )\n",
        "    IMAGENET1K_V2 = Weights(\n",
        "        url=\"https://download.pytorch.org/models/wide_resnet50_2-9ba9bcbe.pth\",\n",
        "        transforms=partial(ImageClassification, crop_size=224, resize_size=232),\n",
        "        meta={\n",
        "            **_COMMON_META,\n",
        "            \"num_params\": 68883240,\n",
        "            \"recipe\": \"https://github.com/pytorch/vision/issues/3995#new-recipe-with-fixres\",\n",
        "            \"_metrics\": {\n",
        "                \"ImageNet-1K\": {\n",
        "                    \"acc@1\": 81.602,\n",
        "                    \"acc@5\": 95.758,\n",
        "                }\n",
        "            },\n",
        "            \"_ops\": 11.398,\n",
        "            \"_file_size\": 263.124,\n",
        "            \"_docs\": \"\"\"\n",
        "                These weights improve upon the results of the original paper by using TorchVision's `new training recipe\n",
        "                <https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/>`_.\n",
        "            \"\"\",\n",
        "        },\n",
        "    )\n",
        "    DEFAULT = IMAGENET1K_V2\n",
        "\n",
        "\n",
        "class Wide_ResNet101_2_Weights(WeightsEnum):\n",
        "    IMAGENET1K_V1 = Weights(\n",
        "        url=\"https://download.pytorch.org/models/wide_resnet101_2-32ee1156.pth\",\n",
        "        transforms=partial(ImageClassification, crop_size=224),\n",
        "        meta={\n",
        "            **_COMMON_META,\n",
        "            \"num_params\": 126886696,\n",
        "            \"recipe\": \"https://github.com/pytorch/vision/pull/912#issue-445437439\",\n",
        "            \"_metrics\": {\n",
        "                \"ImageNet-1K\": {\n",
        "                    \"acc@1\": 78.848,\n",
        "                    \"acc@5\": 94.284,\n",
        "                }\n",
        "            },\n",
        "            \"_ops\": 22.753,\n",
        "            \"_file_size\": 242.896,\n",
        "            \"_docs\": \"\"\"These weights reproduce closely the results of the paper using a simple training recipe.\"\"\",\n",
        "        },\n",
        "    )\n",
        "    IMAGENET1K_V2 = Weights(\n",
        "        url=\"https://download.pytorch.org/models/wide_resnet101_2-d733dc28.pth\",\n",
        "        transforms=partial(ImageClassification, crop_size=224, resize_size=232),\n",
        "        meta={\n",
        "            **_COMMON_META,\n",
        "            \"num_params\": 126886696,\n",
        "            \"recipe\": \"https://github.com/pytorch/vision/issues/3995#new-recipe\",\n",
        "            \"_metrics\": {\n",
        "                \"ImageNet-1K\": {\n",
        "                    \"acc@1\": 82.510,\n",
        "                    \"acc@5\": 96.020,\n",
        "                }\n",
        "            },\n",
        "            \"_ops\": 22.753,\n",
        "            \"_file_size\": 484.747,\n",
        "            \"_docs\": \"\"\"\n",
        "                These weights improve upon the results of the original paper by using TorchVision's `new training recipe\n",
        "                <https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/>`_.\n",
        "            \"\"\",\n",
        "        },\n",
        "    )\n",
        "    DEFAULT = IMAGENET1K_V2\n",
        "\n",
        "\n",
        "@register_model()\n",
        "@handle_legacy_interface(weights=(\"pretrained\", ResNet18_Weights.IMAGENET1K_V1))\n",
        "def resnet18(*, weights: Optional[ResNet18_Weights] = None, progress: bool = True, **kwargs: Any) -> ResNet:\n",
        "    \"\"\"ResNet-18 from `Deep Residual Learning for Image Recognition <https://arxiv.org/pdf/1512.03385.pdf>`__.\n",
        "\n",
        "    Args:\n",
        "        weights (:class:`~torchvision.models.ResNet18_Weights`, optional): The\n",
        "            pretrained weights to use. See\n",
        "            :class:`~torchvision.models.ResNet18_Weights` below for\n",
        "            more details, and possible values. By default, no pre-trained\n",
        "            weights are used.\n",
        "        progress (bool, optional): If True, displays a progress bar of the\n",
        "            download to stderr. Default is True.\n",
        "        **kwargs: parameters passed to the ``torchvision.models.resnet.ResNet``\n",
        "            base class. Please refer to the `source code\n",
        "            <https://github.com/pytorch/vision/blob/main/torchvision/models/resnet.py>`_\n",
        "            for more details about this class.\n",
        "\n",
        "    .. autoclass:: torchvision.models.ResNet18_Weights\n",
        "        :members:\n",
        "    \"\"\"\n",
        "    weights = ResNet18_Weights.verify(weights)\n",
        "\n",
        "    return _resnet(BasicBlock, [2, 2, 2, 2], weights, progress, **kwargs)\n",
        "\n",
        "\n",
        "@register_model()\n",
        "@handle_legacy_interface(weights=(\"pretrained\", ResNet34_Weights.IMAGENET1K_V1))\n",
        "def resnet34(*, weights: Optional[ResNet34_Weights] = None, progress: bool = True, **kwargs: Any) -> ResNet:\n",
        "    \"\"\"ResNet-34 from `Deep Residual Learning for Image Recognition <https://arxiv.org/pdf/1512.03385.pdf>`__.\n",
        "\n",
        "    Args:\n",
        "        weights (:class:`~torchvision.models.ResNet34_Weights`, optional): The\n",
        "            pretrained weights to use. See\n",
        "            :class:`~torchvision.models.ResNet34_Weights` below for\n",
        "            more details, and possible values. By default, no pre-trained\n",
        "            weights are used.\n",
        "        progress (bool, optional): If True, displays a progress bar of the\n",
        "            download to stderr. Default is True.\n",
        "        **kwargs: parameters passed to the ``torchvision.models.resnet.ResNet``\n",
        "            base class. Please refer to the `source code\n",
        "            <https://github.com/pytorch/vision/blob/main/torchvision/models/resnet.py>`_\n",
        "            for more details about this class.\n",
        "\n",
        "    .. autoclass:: torchvision.models.ResNet34_Weights\n",
        "        :members:\n",
        "    \"\"\"\n",
        "    weights = ResNet34_Weights.verify(weights)\n",
        "\n",
        "    return _resnet(BasicBlock, [3, 4, 6, 3], weights, progress, **kwargs)\n",
        "\n",
        "\n",
        "@register_model()\n",
        "@handle_legacy_interface(weights=(\"pretrained\", ResNet50_Weights.IMAGENET1K_V1))\n",
        "def resnet50(*, weights: Optional[ResNet50_Weights] = None, progress: bool = True, **kwargs: Any) -> ResNet:\n",
        "    \"\"\"ResNet-50 from `Deep Residual Learning for Image Recognition <https://arxiv.org/pdf/1512.03385.pdf>`__.\n",
        "\n",
        "    .. note::\n",
        "       The bottleneck of TorchVision places the stride for downsampling to the second 3x3\n",
        "       convolution while the original paper places it to the first 1x1 convolution.\n",
        "       This variant improves the accuracy and is known as `ResNet V1.5\n",
        "       <https://ngc.nvidia.com/catalog/model-scripts/nvidia:resnet_50_v1_5_for_pytorch>`_.\n",
        "\n",
        "    Args:\n",
        "        weights (:class:`~torchvision.models.ResNet50_Weights`, optional): The\n",
        "            pretrained weights to use. See\n",
        "            :class:`~torchvision.models.ResNet50_Weights` below for\n",
        "            more details, and possible values. By default, no pre-trained\n",
        "            weights are used.\n",
        "        progress (bool, optional): If True, displays a progress bar of the\n",
        "            download to stderr. Default is True.\n",
        "        **kwargs: parameters passed to the ``torchvision.models.resnet.ResNet``\n",
        "            base class. Please refer to the `source code\n",
        "            <https://github.com/pytorch/vision/blob/main/torchvision/models/resnet.py>`_\n",
        "            for more details about this class.\n",
        "\n",
        "    .. autoclass:: torchvision.models.ResNet50_Weights\n",
        "        :members:\n",
        "    \"\"\"\n",
        "    weights = ResNet50_Weights.verify(weights)\n",
        "\n",
        "    return _resnet(Bottleneck, [3, 4, 6, 3], weights, progress, **kwargs)\n",
        "\n",
        "\n",
        "@register_model()\n",
        "@handle_legacy_interface(weights=(\"pretrained\", ResNet101_Weights.IMAGENET1K_V1))\n",
        "def resnet101(*, weights: Optional[ResNet101_Weights] = None, progress: bool = True, **kwargs: Any) -> ResNet:\n",
        "    \"\"\"ResNet-101 from `Deep Residual Learning for Image Recognition <https://arxiv.org/pdf/1512.03385.pdf>`__.\n",
        "\n",
        "    .. note::\n",
        "       The bottleneck of TorchVision places the stride for downsampling to the second 3x3\n",
        "       convolution while the original paper places it to the first 1x1 convolution.\n",
        "       This variant improves the accuracy and is known as `ResNet V1.5\n",
        "       <https://ngc.nvidia.com/catalog/model-scripts/nvidia:resnet_50_v1_5_for_pytorch>`_.\n",
        "\n",
        "    Args:\n",
        "        weights (:class:`~torchvision.models.ResNet101_Weights`, optional): The\n",
        "            pretrained weights to use. See\n",
        "            :class:`~torchvision.models.ResNet101_Weights` below for\n",
        "            more details, and possible values. By default, no pre-trained\n",
        "            weights are used.\n",
        "        progress (bool, optional): If True, displays a progress bar of the\n",
        "            download to stderr. Default is True.\n",
        "        **kwargs: parameters passed to the ``torchvision.models.resnet.ResNet``\n",
        "            base class. Please refer to the `source code\n",
        "            <https://github.com/pytorch/vision/blob/main/torchvision/models/resnet.py>`_\n",
        "            for more details about this class.\n",
        "\n",
        "    .. autoclass:: torchvision.models.ResNet101_Weights\n",
        "        :members:\n",
        "    \"\"\"\n",
        "    weights = ResNet101_Weights.verify(weights)\n",
        "\n",
        "    return _resnet(Bottleneck, [3, 4, 23, 3], weights, progress, **kwargs)\n",
        "\n",
        "\n",
        "@register_model()\n",
        "@handle_legacy_interface(weights=(\"pretrained\", ResNet152_Weights.IMAGENET1K_V1))\n",
        "def resnet152(*, weights: Optional[ResNet152_Weights] = None, progress: bool = True, **kwargs: Any) -> ResNet:\n",
        "    \"\"\"ResNet-152 from `Deep Residual Learning for Image Recognition <https://arxiv.org/pdf/1512.03385.pdf>`__.\n",
        "\n",
        "    .. note::\n",
        "       The bottleneck of TorchVision places the stride for downsampling to the second 3x3\n",
        "       convolution while the original paper places it to the first 1x1 convolution.\n",
        "       This variant improves the accuracy and is known as `ResNet V1.5\n",
        "       <https://ngc.nvidia.com/catalog/model-scripts/nvidia:resnet_50_v1_5_for_pytorch>`_.\n",
        "\n",
        "    Args:\n",
        "        weights (:class:`~torchvision.models.ResNet152_Weights`, optional): The\n",
        "            pretrained weights to use. See\n",
        "            :class:`~torchvision.models.ResNet152_Weights` below for\n",
        "            more details, and possible values. By default, no pre-trained\n",
        "            weights are used.\n",
        "        progress (bool, optional): If True, displays a progress bar of the\n",
        "            download to stderr. Default is True.\n",
        "        **kwargs: parameters passed to the ``torchvision.models.resnet.ResNet``\n",
        "            base class. Please refer to the `source code\n",
        "            <https://github.com/pytorch/vision/blob/main/torchvision/models/resnet.py>`_\n",
        "            for more details about this class.\n",
        "\n",
        "    .. autoclass:: torchvision.models.ResNet152_Weights\n",
        "        :members:\n",
        "    \"\"\"\n",
        "    weights = ResNet152_Weights.verify(weights)\n",
        "\n",
        "    return _resnet(Bottleneck, [3, 8, 36, 3], weights, progress, **kwargs)\n",
        "\n",
        "\n",
        "@register_model()\n",
        "@handle_legacy_interface(weights=(\"pretrained\", ResNeXt50_32X4D_Weights.IMAGENET1K_V1))\n",
        "def resnext50_32x4d(\n",
        "    *, weights: Optional[ResNeXt50_32X4D_Weights] = None, progress: bool = True, **kwargs: Any\n",
        ") -> ResNet:\n",
        "    \"\"\"ResNeXt-50 32x4d model from\n",
        "    `Aggregated Residual Transformation for Deep Neural Networks <https://arxiv.org/abs/1611.05431>`_.\n",
        "\n",
        "    Args:\n",
        "        weights (:class:`~torchvision.models.ResNeXt50_32X4D_Weights`, optional): The\n",
        "            pretrained weights to use. See\n",
        "            :class:`~torchvision.models.ResNext50_32X4D_Weights` below for\n",
        "            more details, and possible values. By default, no pre-trained\n",
        "            weights are used.\n",
        "        progress (bool, optional): If True, displays a progress bar of the\n",
        "            download to stderr. Default is True.\n",
        "        **kwargs: parameters passed to the ``torchvision.models.resnet.ResNet``\n",
        "            base class. Please refer to the `source code\n",
        "            <https://github.com/pytorch/vision/blob/main/torchvision/models/resnet.py>`_\n",
        "            for more details about this class.\n",
        "    .. autoclass:: torchvision.models.ResNeXt50_32X4D_Weights\n",
        "        :members:\n",
        "    \"\"\"\n",
        "    weights = ResNeXt50_32X4D_Weights.verify(weights)\n",
        "\n",
        "    _ovewrite_named_param(kwargs, \"groups\", 32)\n",
        "    _ovewrite_named_param(kwargs, \"width_per_group\", 4)\n",
        "    return _resnet(Bottleneck, [3, 4, 6, 3], weights, progress, **kwargs)\n",
        "\n",
        "\n",
        "@register_model()\n",
        "@handle_legacy_interface(weights=(\"pretrained\", ResNeXt101_32X8D_Weights.IMAGENET1K_V1))\n",
        "def resnext101_32x8d(\n",
        "    *, weights: Optional[ResNeXt101_32X8D_Weights] = None, progress: bool = True, **kwargs: Any\n",
        ") -> ResNet:\n",
        "    \"\"\"ResNeXt-101 32x8d model from\n",
        "    `Aggregated Residual Transformation for Deep Neural Networks <https://arxiv.org/abs/1611.05431>`_.\n",
        "\n",
        "    Args:\n",
        "        weights (:class:`~torchvision.models.ResNeXt101_32X8D_Weights`, optional): The\n",
        "            pretrained weights to use. See\n",
        "            :class:`~torchvision.models.ResNeXt101_32X8D_Weights` below for\n",
        "            more details, and possible values. By default, no pre-trained\n",
        "            weights are used.\n",
        "        progress (bool, optional): If True, displays a progress bar of the\n",
        "            download to stderr. Default is True.\n",
        "        **kwargs: parameters passed to the ``torchvision.models.resnet.ResNet``\n",
        "            base class. Please refer to the `source code\n",
        "            <https://github.com/pytorch/vision/blob/main/torchvision/models/resnet.py>`_\n",
        "            for more details about this class.\n",
        "    .. autoclass:: torchvision.models.ResNeXt101_32X8D_Weights\n",
        "        :members:\n",
        "    \"\"\"\n",
        "    weights = ResNeXt101_32X8D_Weights.verify(weights)\n",
        "\n",
        "    _ovewrite_named_param(kwargs, \"groups\", 32)\n",
        "    _ovewrite_named_param(kwargs, \"width_per_group\", 8)\n",
        "    return _resnet(Bottleneck, [3, 4, 23, 3], weights, progress, **kwargs)\n",
        "\n",
        "\n",
        "@register_model()\n",
        "@handle_legacy_interface(weights=(\"pretrained\", ResNeXt101_64X4D_Weights.IMAGENET1K_V1))\n",
        "def resnext101_64x4d(\n",
        "    *, weights: Optional[ResNeXt101_64X4D_Weights] = None, progress: bool = True, **kwargs: Any\n",
        ") -> ResNet:\n",
        "    \"\"\"ResNeXt-101 64x4d model from\n",
        "    `Aggregated Residual Transformation for Deep Neural Networks <https://arxiv.org/abs/1611.05431>`_.\n",
        "\n",
        "    Args:\n",
        "        weights (:class:`~torchvision.models.ResNeXt101_64X4D_Weights`, optional): The\n",
        "            pretrained weights to use. See\n",
        "            :class:`~torchvision.models.ResNeXt101_64X4D_Weights` below for\n",
        "            more details, and possible values. By default, no pre-trained\n",
        "            weights are used.\n",
        "        progress (bool, optional): If True, displays a progress bar of the\n",
        "            download to stderr. Default is True.\n",
        "        **kwargs: parameters passed to the ``torchvision.models.resnet.ResNet``\n",
        "            base class. Please refer to the `source code\n",
        "            <https://github.com/pytorch/vision/blob/main/torchvision/models/resnet.py>`_\n",
        "            for more details about this class.\n",
        "    .. autoclass:: torchvision.models.ResNeXt101_64X4D_Weights\n",
        "        :members:\n",
        "    \"\"\"\n",
        "    weights = ResNeXt101_64X4D_Weights.verify(weights)\n",
        "\n",
        "    _ovewrite_named_param(kwargs, \"groups\", 64)\n",
        "    _ovewrite_named_param(kwargs, \"width_per_group\", 4)\n",
        "    return _resnet(Bottleneck, [3, 4, 23, 3], weights, progress, **kwargs)\n",
        "\n",
        "\n",
        "@register_model()\n",
        "@handle_legacy_interface(weights=(\"pretrained\", Wide_ResNet50_2_Weights.IMAGENET1K_V1))\n",
        "def wide_resnet50_2(\n",
        "    *, weights: Optional[Wide_ResNet50_2_Weights] = None, progress: bool = True, **kwargs: Any\n",
        ") -> ResNet:\n",
        "    \"\"\"Wide ResNet-50-2 model from\n",
        "    `Wide Residual Networks <https://arxiv.org/abs/1605.07146>`_.\n",
        "\n",
        "    The model is the same as ResNet except for the bottleneck number of channels\n",
        "    which is twice larger in every block. The number of channels in outer 1x1\n",
        "    convolutions is the same, e.g. last block in ResNet-50 has 2048-512-2048\n",
        "    channels, and in Wide ResNet-50-2 has 2048-1024-2048.\n",
        "\n",
        "    Args:\n",
        "        weights (:class:`~torchvision.models.Wide_ResNet50_2_Weights`, optional): The\n",
        "            pretrained weights to use. See\n",
        "            :class:`~torchvision.models.Wide_ResNet50_2_Weights` below for\n",
        "            more details, and possible values. By default, no pre-trained\n",
        "            weights are used.\n",
        "        progress (bool, optional): If True, displays a progress bar of the\n",
        "            download to stderr. Default is True.\n",
        "        **kwargs: parameters passed to the ``torchvision.models.resnet.ResNet``\n",
        "            base class. Please refer to the `source code\n",
        "            <https://github.com/pytorch/vision/blob/main/torchvision/models/resnet.py>`_\n",
        "            for more details about this class.\n",
        "    .. autoclass:: torchvision.models.Wide_ResNet50_2_Weights\n",
        "        :members:\n",
        "    \"\"\"\n",
        "    weights = Wide_ResNet50_2_Weights.verify(weights)\n",
        "\n",
        "    _ovewrite_named_param(kwargs, \"width_per_group\", 64 * 2)\n",
        "    return _resnet(Bottleneck, [3, 4, 6, 3], weights, progress, **kwargs)\n",
        "\n",
        "\n",
        "@register_model()\n",
        "@handle_legacy_interface(weights=(\"pretrained\", Wide_ResNet101_2_Weights.IMAGENET1K_V1))\n",
        "def wide_resnet101_2(\n",
        "    *, weights: Optional[Wide_ResNet101_2_Weights] = None, progress: bool = True, **kwargs: Any\n",
        ") -> ResNet:\n",
        "    \"\"\"Wide ResNet-101-2 model from\n",
        "    `Wide Residual Networks <https://arxiv.org/abs/1605.07146>`_.\n",
        "\n",
        "    The model is the same as ResNet except for the bottleneck number of channels\n",
        "    which is twice larger in every block. The number of channels in outer 1x1\n",
        "    convolutions is the same, e.g. last block in ResNet-101 has 2048-512-2048\n",
        "    channels, and in Wide ResNet-101-2 has 2048-1024-2048.\n",
        "\n",
        "    Args:\n",
        "        weights (:class:`~torchvision.models.Wide_ResNet101_2_Weights`, optional): The\n",
        "            pretrained weights to use. See\n",
        "            :class:`~torchvision.models.Wide_ResNet101_2_Weights` below for\n",
        "            more details, and possible values. By default, no pre-trained\n",
        "            weights are used.\n",
        "        progress (bool, optional): If True, displays a progress bar of the\n",
        "            download to stderr. Default is True.\n",
        "        **kwargs: parameters passed to the ``torchvision.models.resnet.ResNet``\n",
        "            base class. Please refer to the `source code\n",
        "            <https://github.com/pytorch/vision/blob/main/torchvision/models/resnet.py>`_\n",
        "            for more details about this class.\n",
        "    .. autoclass:: torchvision.models.Wide_ResNet101_2_Weights\n",
        "        :members:\n",
        "    \"\"\"\n",
        "    weights = Wide_ResNet101_2_Weights.verify(weights)\n",
        "\n",
        "    _ovewrite_named_param(kwargs, \"width_per_group\", 64 * 2)\n",
        "    return _resnet(Bottleneck, [3, 4, 23, 3], weights, progress, **kwargs)"
      ]
    }
  ]
}