|
import math |
|
from collections import OrderedDict |
|
from functools import partial |
|
from typing import Any, Callable, Dict, List, Optional, Tuple |
|
|
|
import torch |
|
from torch import nn, Tensor |
|
|
|
from ..ops.misc import Conv2dNormActivation, SqueezeExcitation |
|
from ..transforms._presets import ImageClassification, InterpolationMode |
|
from ..utils import _log_api_usage_once |
|
from ._api import register_model, Weights, WeightsEnum |
|
from ._meta import _IMAGENET_CATEGORIES |
|
from ._utils import _make_divisible, _ovewrite_named_param, handle_legacy_interface |
|
|
|
|
|
__all__ = [ |
|
"RegNet", |
|
"RegNet_Y_400MF_Weights", |
|
"RegNet_Y_800MF_Weights", |
|
"RegNet_Y_1_6GF_Weights", |
|
"RegNet_Y_3_2GF_Weights", |
|
"RegNet_Y_8GF_Weights", |
|
"RegNet_Y_16GF_Weights", |
|
"RegNet_Y_32GF_Weights", |
|
"RegNet_Y_128GF_Weights", |
|
"RegNet_X_400MF_Weights", |
|
"RegNet_X_800MF_Weights", |
|
"RegNet_X_1_6GF_Weights", |
|
"RegNet_X_3_2GF_Weights", |
|
"RegNet_X_8GF_Weights", |
|
"RegNet_X_16GF_Weights", |
|
"RegNet_X_32GF_Weights", |
|
"regnet_y_400mf", |
|
"regnet_y_800mf", |
|
"regnet_y_1_6gf", |
|
"regnet_y_3_2gf", |
|
"regnet_y_8gf", |
|
"regnet_y_16gf", |
|
"regnet_y_32gf", |
|
"regnet_y_128gf", |
|
"regnet_x_400mf", |
|
"regnet_x_800mf", |
|
"regnet_x_1_6gf", |
|
"regnet_x_3_2gf", |
|
"regnet_x_8gf", |
|
"regnet_x_16gf", |
|
"regnet_x_32gf", |
|
] |
|
|
|
|
|
class SimpleStemIN(Conv2dNormActivation): |
|
"""Simple stem for ImageNet: 3x3, BN, ReLU.""" |
|
|
|
def __init__( |
|
self, |
|
width_in: int, |
|
width_out: int, |
|
norm_layer: Callable[..., nn.Module], |
|
activation_layer: Callable[..., nn.Module], |
|
) -> None: |
|
super().__init__( |
|
width_in, width_out, kernel_size=3, stride=2, norm_layer=norm_layer, activation_layer=activation_layer |
|
) |
|
|
|
|
|
class BottleneckTransform(nn.Sequential): |
|
"""Bottleneck transformation: 1x1, 3x3 [+SE], 1x1.""" |
|
|
|
def __init__( |
|
self, |
|
width_in: int, |
|
width_out: int, |
|
stride: int, |
|
norm_layer: Callable[..., nn.Module], |
|
activation_layer: Callable[..., nn.Module], |
|
group_width: int, |
|
bottleneck_multiplier: float, |
|
se_ratio: Optional[float], |
|
) -> None: |
|
layers: OrderedDict[str, nn.Module] = OrderedDict() |
|
w_b = int(round(width_out * bottleneck_multiplier)) |
|
g = w_b // group_width |
|
|
|
layers["a"] = Conv2dNormActivation( |
|
width_in, w_b, kernel_size=1, stride=1, norm_layer=norm_layer, activation_layer=activation_layer |
|
) |
|
layers["b"] = Conv2dNormActivation( |
|
w_b, w_b, kernel_size=3, stride=stride, groups=g, norm_layer=norm_layer, activation_layer=activation_layer |
|
) |
|
|
|
if se_ratio: |
|
|
|
|
|
width_se_out = int(round(se_ratio * width_in)) |
|
layers["se"] = SqueezeExcitation( |
|
input_channels=w_b, |
|
squeeze_channels=width_se_out, |
|
activation=activation_layer, |
|
) |
|
|
|
layers["c"] = Conv2dNormActivation( |
|
w_b, width_out, kernel_size=1, stride=1, norm_layer=norm_layer, activation_layer=None |
|
) |
|
super().__init__(layers) |
|
|
|
|
|
class ResBottleneckBlock(nn.Module): |
|
"""Residual bottleneck block: x + F(x), F = bottleneck transform.""" |
|
|
|
def __init__( |
|
self, |
|
width_in: int, |
|
width_out: int, |
|
stride: int, |
|
norm_layer: Callable[..., nn.Module], |
|
activation_layer: Callable[..., nn.Module], |
|
group_width: int = 1, |
|
bottleneck_multiplier: float = 1.0, |
|
se_ratio: Optional[float] = None, |
|
) -> None: |
|
super().__init__() |
|
|
|
|
|
self.proj = None |
|
should_proj = (width_in != width_out) or (stride != 1) |
|
if should_proj: |
|
self.proj = Conv2dNormActivation( |
|
width_in, width_out, kernel_size=1, stride=stride, norm_layer=norm_layer, activation_layer=None |
|
) |
|
self.f = BottleneckTransform( |
|
width_in, |
|
width_out, |
|
stride, |
|
norm_layer, |
|
activation_layer, |
|
group_width, |
|
bottleneck_multiplier, |
|
se_ratio, |
|
) |
|
self.activation = activation_layer(inplace=True) |
|
|
|
def forward(self, x: Tensor) -> Tensor: |
|
if self.proj is not None: |
|
x = self.proj(x) + self.f(x) |
|
else: |
|
x = x + self.f(x) |
|
return self.activation(x) |
|
|
|
|
|
class AnyStage(nn.Sequential): |
|
"""AnyNet stage (sequence of blocks w/ the same output shape).""" |
|
|
|
def __init__( |
|
self, |
|
width_in: int, |
|
width_out: int, |
|
stride: int, |
|
depth: int, |
|
block_constructor: Callable[..., nn.Module], |
|
norm_layer: Callable[..., nn.Module], |
|
activation_layer: Callable[..., nn.Module], |
|
group_width: int, |
|
bottleneck_multiplier: float, |
|
se_ratio: Optional[float] = None, |
|
stage_index: int = 0, |
|
) -> None: |
|
super().__init__() |
|
|
|
for i in range(depth): |
|
block = block_constructor( |
|
width_in if i == 0 else width_out, |
|
width_out, |
|
stride if i == 0 else 1, |
|
norm_layer, |
|
activation_layer, |
|
group_width, |
|
bottleneck_multiplier, |
|
se_ratio, |
|
) |
|
|
|
self.add_module(f"block{stage_index}-{i}", block) |
|
|
|
|
|
class BlockParams: |
|
def __init__( |
|
self, |
|
depths: List[int], |
|
widths: List[int], |
|
group_widths: List[int], |
|
bottleneck_multipliers: List[float], |
|
strides: List[int], |
|
se_ratio: Optional[float] = None, |
|
) -> None: |
|
self.depths = depths |
|
self.widths = widths |
|
self.group_widths = group_widths |
|
self.bottleneck_multipliers = bottleneck_multipliers |
|
self.strides = strides |
|
self.se_ratio = se_ratio |
|
|
|
@classmethod |
|
def from_init_params( |
|
cls, |
|
depth: int, |
|
w_0: int, |
|
w_a: float, |
|
w_m: float, |
|
group_width: int, |
|
bottleneck_multiplier: float = 1.0, |
|
se_ratio: Optional[float] = None, |
|
**kwargs: Any, |
|
) -> "BlockParams": |
|
""" |
|
Programmatically compute all the per-block settings, |
|
given the RegNet parameters. |
|
|
|
The first step is to compute the quantized linear block parameters, |
|
in log space. Key parameters are: |
|
- `w_a` is the width progression slope |
|
- `w_0` is the initial width |
|
- `w_m` is the width stepping in the log space |
|
|
|
In other terms |
|
`log(block_width) = log(w_0) + w_m * block_capacity`, |
|
with `bock_capacity` ramping up following the w_0 and w_a params. |
|
This block width is finally quantized to multiples of 8. |
|
|
|
The second step is to compute the parameters per stage, |
|
taking into account the skip connection and the final 1x1 convolutions. |
|
We use the fact that the output width is constant within a stage. |
|
""" |
|
|
|
QUANT = 8 |
|
STRIDE = 2 |
|
|
|
if w_a < 0 or w_0 <= 0 or w_m <= 1 or w_0 % 8 != 0: |
|
raise ValueError("Invalid RegNet settings") |
|
|
|
widths_cont = torch.arange(depth) * w_a + w_0 |
|
block_capacity = torch.round(torch.log(widths_cont / w_0) / math.log(w_m)) |
|
block_widths = (torch.round(torch.divide(w_0 * torch.pow(w_m, block_capacity), QUANT)) * QUANT).int().tolist() |
|
num_stages = len(set(block_widths)) |
|
|
|
|
|
split_helper = zip( |
|
block_widths + [0], |
|
[0] + block_widths, |
|
block_widths + [0], |
|
[0] + block_widths, |
|
) |
|
splits = [w != wp or r != rp for w, wp, r, rp in split_helper] |
|
|
|
stage_widths = [w for w, t in zip(block_widths, splits[:-1]) if t] |
|
stage_depths = torch.diff(torch.tensor([d for d, t in enumerate(splits) if t])).int().tolist() |
|
|
|
strides = [STRIDE] * num_stages |
|
bottleneck_multipliers = [bottleneck_multiplier] * num_stages |
|
group_widths = [group_width] * num_stages |
|
|
|
|
|
stage_widths, group_widths = cls._adjust_widths_groups_compatibilty( |
|
stage_widths, bottleneck_multipliers, group_widths |
|
) |
|
|
|
return cls( |
|
depths=stage_depths, |
|
widths=stage_widths, |
|
group_widths=group_widths, |
|
bottleneck_multipliers=bottleneck_multipliers, |
|
strides=strides, |
|
se_ratio=se_ratio, |
|
) |
|
|
|
def _get_expanded_params(self): |
|
return zip(self.widths, self.strides, self.depths, self.group_widths, self.bottleneck_multipliers) |
|
|
|
@staticmethod |
|
def _adjust_widths_groups_compatibilty( |
|
stage_widths: List[int], bottleneck_ratios: List[float], group_widths: List[int] |
|
) -> Tuple[List[int], List[int]]: |
|
""" |
|
Adjusts the compatibility of widths and groups, |
|
depending on the bottleneck ratio. |
|
""" |
|
|
|
widths = [int(w * b) for w, b in zip(stage_widths, bottleneck_ratios)] |
|
group_widths_min = [min(g, w_bot) for g, w_bot in zip(group_widths, widths)] |
|
|
|
|
|
ws_bot = [_make_divisible(w_bot, g) for w_bot, g in zip(widths, group_widths_min)] |
|
stage_widths = [int(w_bot / b) for w_bot, b in zip(ws_bot, bottleneck_ratios)] |
|
return stage_widths, group_widths_min |
|
|
|
|
|
class RegNet(nn.Module): |
|
def __init__( |
|
self, |
|
block_params: BlockParams, |
|
num_classes: int = 1000, |
|
stem_width: int = 32, |
|
stem_type: Optional[Callable[..., nn.Module]] = None, |
|
block_type: Optional[Callable[..., nn.Module]] = None, |
|
norm_layer: Optional[Callable[..., nn.Module]] = None, |
|
activation: Optional[Callable[..., nn.Module]] = None, |
|
) -> None: |
|
super().__init__() |
|
_log_api_usage_once(self) |
|
|
|
if stem_type is None: |
|
stem_type = SimpleStemIN |
|
if norm_layer is None: |
|
norm_layer = nn.BatchNorm2d |
|
if block_type is None: |
|
block_type = ResBottleneckBlock |
|
if activation is None: |
|
activation = nn.ReLU |
|
|
|
|
|
self.stem = stem_type( |
|
3, |
|
stem_width, |
|
norm_layer, |
|
activation, |
|
) |
|
|
|
current_width = stem_width |
|
|
|
blocks = [] |
|
for i, ( |
|
width_out, |
|
stride, |
|
depth, |
|
group_width, |
|
bottleneck_multiplier, |
|
) in enumerate(block_params._get_expanded_params()): |
|
blocks.append( |
|
( |
|
f"block{i+1}", |
|
AnyStage( |
|
current_width, |
|
width_out, |
|
stride, |
|
depth, |
|
block_type, |
|
norm_layer, |
|
activation, |
|
group_width, |
|
bottleneck_multiplier, |
|
block_params.se_ratio, |
|
stage_index=i + 1, |
|
), |
|
) |
|
) |
|
|
|
current_width = width_out |
|
|
|
self.trunk_output = nn.Sequential(OrderedDict(blocks)) |
|
|
|
self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) |
|
self.fc = nn.Linear(in_features=current_width, out_features=num_classes) |
|
|
|
|
|
for m in self.modules(): |
|
if isinstance(m, nn.Conv2d): |
|
|
|
fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels |
|
nn.init.normal_(m.weight, mean=0.0, std=math.sqrt(2.0 / fan_out)) |
|
elif isinstance(m, nn.BatchNorm2d): |
|
nn.init.ones_(m.weight) |
|
nn.init.zeros_(m.bias) |
|
elif isinstance(m, nn.Linear): |
|
nn.init.normal_(m.weight, mean=0.0, std=0.01) |
|
nn.init.zeros_(m.bias) |
|
|
|
def forward(self, x: Tensor) -> Tensor: |
|
x = self.stem(x) |
|
x = self.trunk_output(x) |
|
|
|
x = self.avgpool(x) |
|
x = x.flatten(start_dim=1) |
|
x = self.fc(x) |
|
|
|
return x |
|
|
|
|
|
def _regnet( |
|
block_params: BlockParams, |
|
weights: Optional[WeightsEnum], |
|
progress: bool, |
|
**kwargs: Any, |
|
) -> RegNet: |
|
if weights is not None: |
|
_ovewrite_named_param(kwargs, "num_classes", len(weights.meta["categories"])) |
|
|
|
norm_layer = kwargs.pop("norm_layer", partial(nn.BatchNorm2d, eps=1e-05, momentum=0.1)) |
|
model = RegNet(block_params, norm_layer=norm_layer, **kwargs) |
|
|
|
if weights is not None: |
|
model.load_state_dict(weights.get_state_dict(progress=progress, check_hash=True)) |
|
|
|
return model |
|
|
|
|
|
_COMMON_META: Dict[str, Any] = { |
|
"min_size": (1, 1), |
|
"categories": _IMAGENET_CATEGORIES, |
|
} |
|
|
|
_COMMON_SWAG_META = { |
|
**_COMMON_META, |
|
"recipe": "https://github.com/facebookresearch/SWAG", |
|
"license": "https://github.com/facebookresearch/SWAG/blob/main/LICENSE", |
|
} |
|
|
|
|
|
class RegNet_Y_400MF_Weights(WeightsEnum): |
|
IMAGENET1K_V1 = Weights( |
|
url="https://download.pytorch.org/models/regnet_y_400mf-c65dace8.pth", |
|
transforms=partial(ImageClassification, crop_size=224), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 4344144, |
|
"recipe": "https://github.com/pytorch/vision/tree/main/references/classification#small-models", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 74.046, |
|
"acc@5": 91.716, |
|
} |
|
}, |
|
"_ops": 0.402, |
|
"_file_size": 16.806, |
|
"_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""", |
|
}, |
|
) |
|
IMAGENET1K_V2 = Weights( |
|
url="https://download.pytorch.org/models/regnet_y_400mf-e6988f5f.pth", |
|
transforms=partial(ImageClassification, crop_size=224, resize_size=232), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 4344144, |
|
"recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 75.804, |
|
"acc@5": 92.742, |
|
} |
|
}, |
|
"_ops": 0.402, |
|
"_file_size": 16.806, |
|
"_docs": """ |
|
These weights improve upon the results of the original paper by using a modified version of TorchVision's |
|
`new training recipe |
|
<https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/>`_. |
|
""", |
|
}, |
|
) |
|
DEFAULT = IMAGENET1K_V2 |
|
|
|
|
|
class RegNet_Y_800MF_Weights(WeightsEnum): |
|
IMAGENET1K_V1 = Weights( |
|
url="https://download.pytorch.org/models/regnet_y_800mf-1b27b58c.pth", |
|
transforms=partial(ImageClassification, crop_size=224), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 6432512, |
|
"recipe": "https://github.com/pytorch/vision/tree/main/references/classification#small-models", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 76.420, |
|
"acc@5": 93.136, |
|
} |
|
}, |
|
"_ops": 0.834, |
|
"_file_size": 24.774, |
|
"_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""", |
|
}, |
|
) |
|
IMAGENET1K_V2 = Weights( |
|
url="https://download.pytorch.org/models/regnet_y_800mf-58fc7688.pth", |
|
transforms=partial(ImageClassification, crop_size=224, resize_size=232), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 6432512, |
|
"recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 78.828, |
|
"acc@5": 94.502, |
|
} |
|
}, |
|
"_ops": 0.834, |
|
"_file_size": 24.774, |
|
"_docs": """ |
|
These weights improve upon the results of the original paper by using a modified version of TorchVision's |
|
`new training recipe |
|
<https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/>`_. |
|
""", |
|
}, |
|
) |
|
DEFAULT = IMAGENET1K_V2 |
|
|
|
|
|
class RegNet_Y_1_6GF_Weights(WeightsEnum): |
|
IMAGENET1K_V1 = Weights( |
|
url="https://download.pytorch.org/models/regnet_y_1_6gf-b11a554e.pth", |
|
transforms=partial(ImageClassification, crop_size=224), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 11202430, |
|
"recipe": "https://github.com/pytorch/vision/tree/main/references/classification#small-models", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 77.950, |
|
"acc@5": 93.966, |
|
} |
|
}, |
|
"_ops": 1.612, |
|
"_file_size": 43.152, |
|
"_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""", |
|
}, |
|
) |
|
IMAGENET1K_V2 = Weights( |
|
url="https://download.pytorch.org/models/regnet_y_1_6gf-0d7bc02a.pth", |
|
transforms=partial(ImageClassification, crop_size=224, resize_size=232), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 11202430, |
|
"recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 80.876, |
|
"acc@5": 95.444, |
|
} |
|
}, |
|
"_ops": 1.612, |
|
"_file_size": 43.152, |
|
"_docs": """ |
|
These weights improve upon the results of the original paper by using a modified version of TorchVision's |
|
`new training recipe |
|
<https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/>`_. |
|
""", |
|
}, |
|
) |
|
DEFAULT = IMAGENET1K_V2 |
|
|
|
|
|
class RegNet_Y_3_2GF_Weights(WeightsEnum): |
|
IMAGENET1K_V1 = Weights( |
|
url="https://download.pytorch.org/models/regnet_y_3_2gf-b5a9779c.pth", |
|
transforms=partial(ImageClassification, crop_size=224), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 19436338, |
|
"recipe": "https://github.com/pytorch/vision/tree/main/references/classification#medium-models", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 78.948, |
|
"acc@5": 94.576, |
|
} |
|
}, |
|
"_ops": 3.176, |
|
"_file_size": 74.567, |
|
"_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""", |
|
}, |
|
) |
|
IMAGENET1K_V2 = Weights( |
|
url="https://download.pytorch.org/models/regnet_y_3_2gf-9180c971.pth", |
|
transforms=partial(ImageClassification, crop_size=224, resize_size=232), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 19436338, |
|
"recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 81.982, |
|
"acc@5": 95.972, |
|
} |
|
}, |
|
"_ops": 3.176, |
|
"_file_size": 74.567, |
|
"_docs": """ |
|
These weights improve upon the results of the original paper by using a modified version of TorchVision's |
|
`new training recipe |
|
<https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/>`_. |
|
""", |
|
}, |
|
) |
|
DEFAULT = IMAGENET1K_V2 |
|
|
|
|
|
class RegNet_Y_8GF_Weights(WeightsEnum): |
|
IMAGENET1K_V1 = Weights( |
|
url="https://download.pytorch.org/models/regnet_y_8gf-d0d0e4a8.pth", |
|
transforms=partial(ImageClassification, crop_size=224), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 39381472, |
|
"recipe": "https://github.com/pytorch/vision/tree/main/references/classification#medium-models", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 80.032, |
|
"acc@5": 95.048, |
|
} |
|
}, |
|
"_ops": 8.473, |
|
"_file_size": 150.701, |
|
"_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""", |
|
}, |
|
) |
|
IMAGENET1K_V2 = Weights( |
|
url="https://download.pytorch.org/models/regnet_y_8gf-dc2b1b54.pth", |
|
transforms=partial(ImageClassification, crop_size=224, resize_size=232), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 39381472, |
|
"recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 82.828, |
|
"acc@5": 96.330, |
|
} |
|
}, |
|
"_ops": 8.473, |
|
"_file_size": 150.701, |
|
"_docs": """ |
|
These weights improve upon the results of the original paper by using a modified version of TorchVision's |
|
`new training recipe |
|
<https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/>`_. |
|
""", |
|
}, |
|
) |
|
DEFAULT = IMAGENET1K_V2 |
|
|
|
|
|
class RegNet_Y_16GF_Weights(WeightsEnum): |
|
IMAGENET1K_V1 = Weights( |
|
url="https://download.pytorch.org/models/regnet_y_16gf-9e6ed7dd.pth", |
|
transforms=partial(ImageClassification, crop_size=224), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 83590140, |
|
"recipe": "https://github.com/pytorch/vision/tree/main/references/classification#large-models", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 80.424, |
|
"acc@5": 95.240, |
|
} |
|
}, |
|
"_ops": 15.912, |
|
"_file_size": 319.49, |
|
"_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""", |
|
}, |
|
) |
|
IMAGENET1K_V2 = Weights( |
|
url="https://download.pytorch.org/models/regnet_y_16gf-3e4a00f9.pth", |
|
transforms=partial(ImageClassification, crop_size=224, resize_size=232), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 83590140, |
|
"recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 82.886, |
|
"acc@5": 96.328, |
|
} |
|
}, |
|
"_ops": 15.912, |
|
"_file_size": 319.49, |
|
"_docs": """ |
|
These weights improve upon the results of the original paper by using a modified version of TorchVision's |
|
`new training recipe |
|
<https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/>`_. |
|
""", |
|
}, |
|
) |
|
IMAGENET1K_SWAG_E2E_V1 = Weights( |
|
url="https://download.pytorch.org/models/regnet_y_16gf_swag-43afe44d.pth", |
|
transforms=partial( |
|
ImageClassification, crop_size=384, resize_size=384, interpolation=InterpolationMode.BICUBIC |
|
), |
|
meta={ |
|
**_COMMON_SWAG_META, |
|
"num_params": 83590140, |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 86.012, |
|
"acc@5": 98.054, |
|
} |
|
}, |
|
"_ops": 46.735, |
|
"_file_size": 319.49, |
|
"_docs": """ |
|
These weights are learnt via transfer learning by end-to-end fine-tuning the original |
|
`SWAG <https://arxiv.org/abs/2201.08371>`_ weights on ImageNet-1K data. |
|
""", |
|
}, |
|
) |
|
IMAGENET1K_SWAG_LINEAR_V1 = Weights( |
|
url="https://download.pytorch.org/models/regnet_y_16gf_lc_swag-f3ec0043.pth", |
|
transforms=partial( |
|
ImageClassification, crop_size=224, resize_size=224, interpolation=InterpolationMode.BICUBIC |
|
), |
|
meta={ |
|
**_COMMON_SWAG_META, |
|
"recipe": "https://github.com/pytorch/vision/pull/5793", |
|
"num_params": 83590140, |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 83.976, |
|
"acc@5": 97.244, |
|
} |
|
}, |
|
"_ops": 15.912, |
|
"_file_size": 319.49, |
|
"_docs": """ |
|
These weights are composed of the original frozen `SWAG <https://arxiv.org/abs/2201.08371>`_ trunk |
|
weights and a linear classifier learnt on top of them trained on ImageNet-1K data. |
|
""", |
|
}, |
|
) |
|
DEFAULT = IMAGENET1K_V2 |
|
|
|
|
|
class RegNet_Y_32GF_Weights(WeightsEnum): |
|
IMAGENET1K_V1 = Weights( |
|
url="https://download.pytorch.org/models/regnet_y_32gf-4dee3f7a.pth", |
|
transforms=partial(ImageClassification, crop_size=224), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 145046770, |
|
"recipe": "https://github.com/pytorch/vision/tree/main/references/classification#large-models", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 80.878, |
|
"acc@5": 95.340, |
|
} |
|
}, |
|
"_ops": 32.28, |
|
"_file_size": 554.076, |
|
"_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""", |
|
}, |
|
) |
|
IMAGENET1K_V2 = Weights( |
|
url="https://download.pytorch.org/models/regnet_y_32gf-8db6d4b5.pth", |
|
transforms=partial(ImageClassification, crop_size=224, resize_size=232), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 145046770, |
|
"recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 83.368, |
|
"acc@5": 96.498, |
|
} |
|
}, |
|
"_ops": 32.28, |
|
"_file_size": 554.076, |
|
"_docs": """ |
|
These weights improve upon the results of the original paper by using a modified version of TorchVision's |
|
`new training recipe |
|
<https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/>`_. |
|
""", |
|
}, |
|
) |
|
IMAGENET1K_SWAG_E2E_V1 = Weights( |
|
url="https://download.pytorch.org/models/regnet_y_32gf_swag-04fdfa75.pth", |
|
transforms=partial( |
|
ImageClassification, crop_size=384, resize_size=384, interpolation=InterpolationMode.BICUBIC |
|
), |
|
meta={ |
|
**_COMMON_SWAG_META, |
|
"num_params": 145046770, |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 86.838, |
|
"acc@5": 98.362, |
|
} |
|
}, |
|
"_ops": 94.826, |
|
"_file_size": 554.076, |
|
"_docs": """ |
|
These weights are learnt via transfer learning by end-to-end fine-tuning the original |
|
`SWAG <https://arxiv.org/abs/2201.08371>`_ weights on ImageNet-1K data. |
|
""", |
|
}, |
|
) |
|
IMAGENET1K_SWAG_LINEAR_V1 = Weights( |
|
url="https://download.pytorch.org/models/regnet_y_32gf_lc_swag-e1583746.pth", |
|
transforms=partial( |
|
ImageClassification, crop_size=224, resize_size=224, interpolation=InterpolationMode.BICUBIC |
|
), |
|
meta={ |
|
**_COMMON_SWAG_META, |
|
"recipe": "https://github.com/pytorch/vision/pull/5793", |
|
"num_params": 145046770, |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 84.622, |
|
"acc@5": 97.480, |
|
} |
|
}, |
|
"_ops": 32.28, |
|
"_file_size": 554.076, |
|
"_docs": """ |
|
These weights are composed of the original frozen `SWAG <https://arxiv.org/abs/2201.08371>`_ trunk |
|
weights and a linear classifier learnt on top of them trained on ImageNet-1K data. |
|
""", |
|
}, |
|
) |
|
DEFAULT = IMAGENET1K_V2 |
|
|
|
|
|
class RegNet_Y_128GF_Weights(WeightsEnum): |
|
IMAGENET1K_SWAG_E2E_V1 = Weights( |
|
url="https://download.pytorch.org/models/regnet_y_128gf_swag-c8ce3e52.pth", |
|
transforms=partial( |
|
ImageClassification, crop_size=384, resize_size=384, interpolation=InterpolationMode.BICUBIC |
|
), |
|
meta={ |
|
**_COMMON_SWAG_META, |
|
"num_params": 644812894, |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 88.228, |
|
"acc@5": 98.682, |
|
} |
|
}, |
|
"_ops": 374.57, |
|
"_file_size": 2461.564, |
|
"_docs": """ |
|
These weights are learnt via transfer learning by end-to-end fine-tuning the original |
|
`SWAG <https://arxiv.org/abs/2201.08371>`_ weights on ImageNet-1K data. |
|
""", |
|
}, |
|
) |
|
IMAGENET1K_SWAG_LINEAR_V1 = Weights( |
|
url="https://download.pytorch.org/models/regnet_y_128gf_lc_swag-cbe8ce12.pth", |
|
transforms=partial( |
|
ImageClassification, crop_size=224, resize_size=224, interpolation=InterpolationMode.BICUBIC |
|
), |
|
meta={ |
|
**_COMMON_SWAG_META, |
|
"recipe": "https://github.com/pytorch/vision/pull/5793", |
|
"num_params": 644812894, |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 86.068, |
|
"acc@5": 97.844, |
|
} |
|
}, |
|
"_ops": 127.518, |
|
"_file_size": 2461.564, |
|
"_docs": """ |
|
These weights are composed of the original frozen `SWAG <https://arxiv.org/abs/2201.08371>`_ trunk |
|
weights and a linear classifier learnt on top of them trained on ImageNet-1K data. |
|
""", |
|
}, |
|
) |
|
DEFAULT = IMAGENET1K_SWAG_E2E_V1 |
|
|
|
|
|
class RegNet_X_400MF_Weights(WeightsEnum): |
|
IMAGENET1K_V1 = Weights( |
|
url="https://download.pytorch.org/models/regnet_x_400mf-adf1edd5.pth", |
|
transforms=partial(ImageClassification, crop_size=224), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 5495976, |
|
"recipe": "https://github.com/pytorch/vision/tree/main/references/classification#small-models", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 72.834, |
|
"acc@5": 90.950, |
|
} |
|
}, |
|
"_ops": 0.414, |
|
"_file_size": 21.258, |
|
"_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""", |
|
}, |
|
) |
|
IMAGENET1K_V2 = Weights( |
|
url="https://download.pytorch.org/models/regnet_x_400mf-62229a5f.pth", |
|
transforms=partial(ImageClassification, crop_size=224, resize_size=232), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 5495976, |
|
"recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe-with-fixres", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 74.864, |
|
"acc@5": 92.322, |
|
} |
|
}, |
|
"_ops": 0.414, |
|
"_file_size": 21.257, |
|
"_docs": """ |
|
These weights improve upon the results of the original paper by using a modified version of TorchVision's |
|
`new training recipe |
|
<https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/>`_. |
|
""", |
|
}, |
|
) |
|
DEFAULT = IMAGENET1K_V2 |
|
|
|
|
|
class RegNet_X_800MF_Weights(WeightsEnum): |
|
IMAGENET1K_V1 = Weights( |
|
url="https://download.pytorch.org/models/regnet_x_800mf-ad17e45c.pth", |
|
transforms=partial(ImageClassification, crop_size=224), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 7259656, |
|
"recipe": "https://github.com/pytorch/vision/tree/main/references/classification#small-models", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 75.212, |
|
"acc@5": 92.348, |
|
} |
|
}, |
|
"_ops": 0.8, |
|
"_file_size": 27.945, |
|
"_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""", |
|
}, |
|
) |
|
IMAGENET1K_V2 = Weights( |
|
url="https://download.pytorch.org/models/regnet_x_800mf-94a99ebd.pth", |
|
transforms=partial(ImageClassification, crop_size=224, resize_size=232), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 7259656, |
|
"recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe-with-fixres", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 77.522, |
|
"acc@5": 93.826, |
|
} |
|
}, |
|
"_ops": 0.8, |
|
"_file_size": 27.945, |
|
"_docs": """ |
|
These weights improve upon the results of the original paper by using a modified version of TorchVision's |
|
`new training recipe |
|
<https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/>`_. |
|
""", |
|
}, |
|
) |
|
DEFAULT = IMAGENET1K_V2 |
|
|
|
|
|
class RegNet_X_1_6GF_Weights(WeightsEnum): |
|
IMAGENET1K_V1 = Weights( |
|
url="https://download.pytorch.org/models/regnet_x_1_6gf-e3633e7f.pth", |
|
transforms=partial(ImageClassification, crop_size=224), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 9190136, |
|
"recipe": "https://github.com/pytorch/vision/tree/main/references/classification#small-models", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 77.040, |
|
"acc@5": 93.440, |
|
} |
|
}, |
|
"_ops": 1.603, |
|
"_file_size": 35.339, |
|
"_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""", |
|
}, |
|
) |
|
IMAGENET1K_V2 = Weights( |
|
url="https://download.pytorch.org/models/regnet_x_1_6gf-a12f2b72.pth", |
|
transforms=partial(ImageClassification, crop_size=224, resize_size=232), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 9190136, |
|
"recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe-with-fixres", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 79.668, |
|
"acc@5": 94.922, |
|
} |
|
}, |
|
"_ops": 1.603, |
|
"_file_size": 35.339, |
|
"_docs": """ |
|
These weights improve upon the results of the original paper by using a modified version of TorchVision's |
|
`new training recipe |
|
<https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/>`_. |
|
""", |
|
}, |
|
) |
|
DEFAULT = IMAGENET1K_V2 |
|
|
|
|
|
class RegNet_X_3_2GF_Weights(WeightsEnum): |
|
IMAGENET1K_V1 = Weights( |
|
url="https://download.pytorch.org/models/regnet_x_3_2gf-f342aeae.pth", |
|
transforms=partial(ImageClassification, crop_size=224), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 15296552, |
|
"recipe": "https://github.com/pytorch/vision/tree/main/references/classification#medium-models", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 78.364, |
|
"acc@5": 93.992, |
|
} |
|
}, |
|
"_ops": 3.177, |
|
"_file_size": 58.756, |
|
"_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""", |
|
}, |
|
) |
|
IMAGENET1K_V2 = Weights( |
|
url="https://download.pytorch.org/models/regnet_x_3_2gf-7071aa85.pth", |
|
transforms=partial(ImageClassification, crop_size=224, resize_size=232), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 15296552, |
|
"recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 81.196, |
|
"acc@5": 95.430, |
|
} |
|
}, |
|
"_ops": 3.177, |
|
"_file_size": 58.756, |
|
"_docs": """ |
|
These weights improve upon the results of the original paper by using a modified version of TorchVision's |
|
`new training recipe |
|
<https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/>`_. |
|
""", |
|
}, |
|
) |
|
DEFAULT = IMAGENET1K_V2 |
|
|
|
|
|
class RegNet_X_8GF_Weights(WeightsEnum): |
|
IMAGENET1K_V1 = Weights( |
|
url="https://download.pytorch.org/models/regnet_x_8gf-03ceed89.pth", |
|
transforms=partial(ImageClassification, crop_size=224), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 39572648, |
|
"recipe": "https://github.com/pytorch/vision/tree/main/references/classification#medium-models", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 79.344, |
|
"acc@5": 94.686, |
|
} |
|
}, |
|
"_ops": 7.995, |
|
"_file_size": 151.456, |
|
"_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""", |
|
}, |
|
) |
|
IMAGENET1K_V2 = Weights( |
|
url="https://download.pytorch.org/models/regnet_x_8gf-2b70d774.pth", |
|
transforms=partial(ImageClassification, crop_size=224, resize_size=232), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 39572648, |
|
"recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 81.682, |
|
"acc@5": 95.678, |
|
} |
|
}, |
|
"_ops": 7.995, |
|
"_file_size": 151.456, |
|
"_docs": """ |
|
These weights improve upon the results of the original paper by using a modified version of TorchVision's |
|
`new training recipe |
|
<https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/>`_. |
|
""", |
|
}, |
|
) |
|
DEFAULT = IMAGENET1K_V2 |
|
|
|
|
|
class RegNet_X_16GF_Weights(WeightsEnum): |
|
IMAGENET1K_V1 = Weights( |
|
url="https://download.pytorch.org/models/regnet_x_16gf-2007eb11.pth", |
|
transforms=partial(ImageClassification, crop_size=224), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 54278536, |
|
"recipe": "https://github.com/pytorch/vision/tree/main/references/classification#medium-models", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 80.058, |
|
"acc@5": 94.944, |
|
} |
|
}, |
|
"_ops": 15.941, |
|
"_file_size": 207.627, |
|
"_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""", |
|
}, |
|
) |
|
IMAGENET1K_V2 = Weights( |
|
url="https://download.pytorch.org/models/regnet_x_16gf-ba3796d7.pth", |
|
transforms=partial(ImageClassification, crop_size=224, resize_size=232), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 54278536, |
|
"recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 82.716, |
|
"acc@5": 96.196, |
|
} |
|
}, |
|
"_ops": 15.941, |
|
"_file_size": 207.627, |
|
"_docs": """ |
|
These weights improve upon the results of the original paper by using a modified version of TorchVision's |
|
`new training recipe |
|
<https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/>`_. |
|
""", |
|
}, |
|
) |
|
DEFAULT = IMAGENET1K_V2 |
|
|
|
|
|
class RegNet_X_32GF_Weights(WeightsEnum): |
|
IMAGENET1K_V1 = Weights( |
|
url="https://download.pytorch.org/models/regnet_x_32gf-9d47f8d0.pth", |
|
transforms=partial(ImageClassification, crop_size=224), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 107811560, |
|
"recipe": "https://github.com/pytorch/vision/tree/main/references/classification#large-models", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 80.622, |
|
"acc@5": 95.248, |
|
} |
|
}, |
|
"_ops": 31.736, |
|
"_file_size": 412.039, |
|
"_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""", |
|
}, |
|
) |
|
IMAGENET1K_V2 = Weights( |
|
url="https://download.pytorch.org/models/regnet_x_32gf-6eb8fdc6.pth", |
|
transforms=partial(ImageClassification, crop_size=224, resize_size=232), |
|
meta={ |
|
**_COMMON_META, |
|
"num_params": 107811560, |
|
"recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe", |
|
"_metrics": { |
|
"ImageNet-1K": { |
|
"acc@1": 83.014, |
|
"acc@5": 96.288, |
|
} |
|
}, |
|
"_ops": 31.736, |
|
"_file_size": 412.039, |
|
"_docs": """ |
|
These weights improve upon the results of the original paper by using a modified version of TorchVision's |
|
`new training recipe |
|
<https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/>`_. |
|
""", |
|
}, |
|
) |
|
DEFAULT = IMAGENET1K_V2 |
|
|
|
|
|
@register_model() |
|
@handle_legacy_interface(weights=("pretrained", RegNet_Y_400MF_Weights.IMAGENET1K_V1)) |
|
def regnet_y_400mf(*, weights: Optional[RegNet_Y_400MF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet: |
|
""" |
|
Constructs a RegNetY_400MF architecture from |
|
`Designing Network Design Spaces <https://arxiv.org/abs/2003.13678>`_. |
|
|
|
Args: |
|
weights (:class:`~torchvision.models.RegNet_Y_400MF_Weights`, optional): The pretrained weights to use. |
|
See :class:`~torchvision.models.RegNet_Y_400MF_Weights` below for more details and possible values. |
|
By default, no pretrained weights are used. |
|
progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True. |
|
**kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or |
|
``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code |
|
<https://github.com/pytorch/vision/blob/main/torchvision/models/regnet.py>`_ |
|
for more detail about the classes. |
|
|
|
.. autoclass:: torchvision.models.RegNet_Y_400MF_Weights |
|
:members: |
|
""" |
|
weights = RegNet_Y_400MF_Weights.verify(weights) |
|
|
|
params = BlockParams.from_init_params(depth=16, w_0=48, w_a=27.89, w_m=2.09, group_width=8, se_ratio=0.25, **kwargs) |
|
return _regnet(params, weights, progress, **kwargs) |
|
|
|
|
|
@register_model() |
|
@handle_legacy_interface(weights=("pretrained", RegNet_Y_800MF_Weights.IMAGENET1K_V1)) |
|
def regnet_y_800mf(*, weights: Optional[RegNet_Y_800MF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet: |
|
""" |
|
Constructs a RegNetY_800MF architecture from |
|
`Designing Network Design Spaces <https://arxiv.org/abs/2003.13678>`_. |
|
|
|
Args: |
|
weights (:class:`~torchvision.models.RegNet_Y_800MF_Weights`, optional): The pretrained weights to use. |
|
See :class:`~torchvision.models.RegNet_Y_800MF_Weights` below for more details and possible values. |
|
By default, no pretrained weights are used. |
|
progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True. |
|
**kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or |
|
``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code |
|
<https://github.com/pytorch/vision/blob/main/torchvision/models/regnet.py>`_ |
|
for more detail about the classes. |
|
|
|
.. autoclass:: torchvision.models.RegNet_Y_800MF_Weights |
|
:members: |
|
""" |
|
weights = RegNet_Y_800MF_Weights.verify(weights) |
|
|
|
params = BlockParams.from_init_params(depth=14, w_0=56, w_a=38.84, w_m=2.4, group_width=16, se_ratio=0.25, **kwargs) |
|
return _regnet(params, weights, progress, **kwargs) |
|
|
|
|
|
@register_model() |
|
@handle_legacy_interface(weights=("pretrained", RegNet_Y_1_6GF_Weights.IMAGENET1K_V1)) |
|
def regnet_y_1_6gf(*, weights: Optional[RegNet_Y_1_6GF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet: |
|
""" |
|
Constructs a RegNetY_1.6GF architecture from |
|
`Designing Network Design Spaces <https://arxiv.org/abs/2003.13678>`_. |
|
|
|
Args: |
|
weights (:class:`~torchvision.models.RegNet_Y_1_6GF_Weights`, optional): The pretrained weights to use. |
|
See :class:`~torchvision.models.RegNet_Y_1_6GF_Weights` below for more details and possible values. |
|
By default, no pretrained weights are used. |
|
progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True. |
|
**kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or |
|
``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code |
|
<https://github.com/pytorch/vision/blob/main/torchvision/models/regnet.py>`_ |
|
for more detail about the classes. |
|
|
|
.. autoclass:: torchvision.models.RegNet_Y_1_6GF_Weights |
|
:members: |
|
""" |
|
weights = RegNet_Y_1_6GF_Weights.verify(weights) |
|
|
|
params = BlockParams.from_init_params( |
|
depth=27, w_0=48, w_a=20.71, w_m=2.65, group_width=24, se_ratio=0.25, **kwargs |
|
) |
|
return _regnet(params, weights, progress, **kwargs) |
|
|
|
|
|
@register_model() |
|
@handle_legacy_interface(weights=("pretrained", RegNet_Y_3_2GF_Weights.IMAGENET1K_V1)) |
|
def regnet_y_3_2gf(*, weights: Optional[RegNet_Y_3_2GF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet: |
|
""" |
|
Constructs a RegNetY_3.2GF architecture from |
|
`Designing Network Design Spaces <https://arxiv.org/abs/2003.13678>`_. |
|
|
|
Args: |
|
weights (:class:`~torchvision.models.RegNet_Y_3_2GF_Weights`, optional): The pretrained weights to use. |
|
See :class:`~torchvision.models.RegNet_Y_3_2GF_Weights` below for more details and possible values. |
|
By default, no pretrained weights are used. |
|
progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True. |
|
**kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or |
|
``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code |
|
<https://github.com/pytorch/vision/blob/main/torchvision/models/regnet.py>`_ |
|
for more detail about the classes. |
|
|
|
.. autoclass:: torchvision.models.RegNet_Y_3_2GF_Weights |
|
:members: |
|
""" |
|
weights = RegNet_Y_3_2GF_Weights.verify(weights) |
|
|
|
params = BlockParams.from_init_params( |
|
depth=21, w_0=80, w_a=42.63, w_m=2.66, group_width=24, se_ratio=0.25, **kwargs |
|
) |
|
return _regnet(params, weights, progress, **kwargs) |
|
|
|
|
|
@register_model() |
|
@handle_legacy_interface(weights=("pretrained", RegNet_Y_8GF_Weights.IMAGENET1K_V1)) |
|
def regnet_y_8gf(*, weights: Optional[RegNet_Y_8GF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet: |
|
""" |
|
Constructs a RegNetY_8GF architecture from |
|
`Designing Network Design Spaces <https://arxiv.org/abs/2003.13678>`_. |
|
|
|
Args: |
|
weights (:class:`~torchvision.models.RegNet_Y_8GF_Weights`, optional): The pretrained weights to use. |
|
See :class:`~torchvision.models.RegNet_Y_8GF_Weights` below for more details and possible values. |
|
By default, no pretrained weights are used. |
|
progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True. |
|
**kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or |
|
``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code |
|
<https://github.com/pytorch/vision/blob/main/torchvision/models/regnet.py>`_ |
|
for more detail about the classes. |
|
|
|
.. autoclass:: torchvision.models.RegNet_Y_8GF_Weights |
|
:members: |
|
""" |
|
weights = RegNet_Y_8GF_Weights.verify(weights) |
|
|
|
params = BlockParams.from_init_params( |
|
depth=17, w_0=192, w_a=76.82, w_m=2.19, group_width=56, se_ratio=0.25, **kwargs |
|
) |
|
return _regnet(params, weights, progress, **kwargs) |
|
|
|
|
|
@register_model() |
|
@handle_legacy_interface(weights=("pretrained", RegNet_Y_16GF_Weights.IMAGENET1K_V1)) |
|
def regnet_y_16gf(*, weights: Optional[RegNet_Y_16GF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet: |
|
""" |
|
Constructs a RegNetY_16GF architecture from |
|
`Designing Network Design Spaces <https://arxiv.org/abs/2003.13678>`_. |
|
|
|
Args: |
|
weights (:class:`~torchvision.models.RegNet_Y_16GF_Weights`, optional): The pretrained weights to use. |
|
See :class:`~torchvision.models.RegNet_Y_16GF_Weights` below for more details and possible values. |
|
By default, no pretrained weights are used. |
|
progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True. |
|
**kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or |
|
``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code |
|
<https://github.com/pytorch/vision/blob/main/torchvision/models/regnet.py>`_ |
|
for more detail about the classes. |
|
|
|
.. autoclass:: torchvision.models.RegNet_Y_16GF_Weights |
|
:members: |
|
""" |
|
weights = RegNet_Y_16GF_Weights.verify(weights) |
|
|
|
params = BlockParams.from_init_params( |
|
depth=18, w_0=200, w_a=106.23, w_m=2.48, group_width=112, se_ratio=0.25, **kwargs |
|
) |
|
return _regnet(params, weights, progress, **kwargs) |
|
|
|
|
|
@register_model() |
|
@handle_legacy_interface(weights=("pretrained", RegNet_Y_32GF_Weights.IMAGENET1K_V1)) |
|
def regnet_y_32gf(*, weights: Optional[RegNet_Y_32GF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet: |
|
""" |
|
Constructs a RegNetY_32GF architecture from |
|
`Designing Network Design Spaces <https://arxiv.org/abs/2003.13678>`_. |
|
|
|
Args: |
|
weights (:class:`~torchvision.models.RegNet_Y_32GF_Weights`, optional): The pretrained weights to use. |
|
See :class:`~torchvision.models.RegNet_Y_32GF_Weights` below for more details and possible values. |
|
By default, no pretrained weights are used. |
|
progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True. |
|
**kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or |
|
``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code |
|
<https://github.com/pytorch/vision/blob/main/torchvision/models/regnet.py>`_ |
|
for more detail about the classes. |
|
|
|
.. autoclass:: torchvision.models.RegNet_Y_32GF_Weights |
|
:members: |
|
""" |
|
weights = RegNet_Y_32GF_Weights.verify(weights) |
|
|
|
params = BlockParams.from_init_params( |
|
depth=20, w_0=232, w_a=115.89, w_m=2.53, group_width=232, se_ratio=0.25, **kwargs |
|
) |
|
return _regnet(params, weights, progress, **kwargs) |
|
|
|
|
|
@register_model() |
|
@handle_legacy_interface(weights=("pretrained", None)) |
|
def regnet_y_128gf(*, weights: Optional[RegNet_Y_128GF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet: |
|
""" |
|
Constructs a RegNetY_128GF architecture from |
|
`Designing Network Design Spaces <https://arxiv.org/abs/2003.13678>`_. |
|
|
|
Args: |
|
weights (:class:`~torchvision.models.RegNet_Y_128GF_Weights`, optional): The pretrained weights to use. |
|
See :class:`~torchvision.models.RegNet_Y_128GF_Weights` below for more details and possible values. |
|
By default, no pretrained weights are used. |
|
progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True. |
|
**kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or |
|
``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code |
|
<https://github.com/pytorch/vision/blob/main/torchvision/models/regnet.py>`_ |
|
for more detail about the classes. |
|
|
|
.. autoclass:: torchvision.models.RegNet_Y_128GF_Weights |
|
:members: |
|
""" |
|
weights = RegNet_Y_128GF_Weights.verify(weights) |
|
|
|
params = BlockParams.from_init_params( |
|
depth=27, w_0=456, w_a=160.83, w_m=2.52, group_width=264, se_ratio=0.25, **kwargs |
|
) |
|
return _regnet(params, weights, progress, **kwargs) |
|
|
|
|
|
@register_model() |
|
@handle_legacy_interface(weights=("pretrained", RegNet_X_400MF_Weights.IMAGENET1K_V1)) |
|
def regnet_x_400mf(*, weights: Optional[RegNet_X_400MF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet: |
|
""" |
|
Constructs a RegNetX_400MF architecture from |
|
`Designing Network Design Spaces <https://arxiv.org/abs/2003.13678>`_. |
|
|
|
Args: |
|
weights (:class:`~torchvision.models.RegNet_X_400MF_Weights`, optional): The pretrained weights to use. |
|
See :class:`~torchvision.models.RegNet_X_400MF_Weights` below for more details and possible values. |
|
By default, no pretrained weights are used. |
|
progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True. |
|
**kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or |
|
``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code |
|
<https://github.com/pytorch/vision/blob/main/torchvision/models/regnet.py>`_ |
|
for more detail about the classes. |
|
|
|
.. autoclass:: torchvision.models.RegNet_X_400MF_Weights |
|
:members: |
|
""" |
|
weights = RegNet_X_400MF_Weights.verify(weights) |
|
|
|
params = BlockParams.from_init_params(depth=22, w_0=24, w_a=24.48, w_m=2.54, group_width=16, **kwargs) |
|
return _regnet(params, weights, progress, **kwargs) |
|
|
|
|
|
@register_model() |
|
@handle_legacy_interface(weights=("pretrained", RegNet_X_800MF_Weights.IMAGENET1K_V1)) |
|
def regnet_x_800mf(*, weights: Optional[RegNet_X_800MF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet: |
|
""" |
|
Constructs a RegNetX_800MF architecture from |
|
`Designing Network Design Spaces <https://arxiv.org/abs/2003.13678>`_. |
|
|
|
Args: |
|
weights (:class:`~torchvision.models.RegNet_X_800MF_Weights`, optional): The pretrained weights to use. |
|
See :class:`~torchvision.models.RegNet_X_800MF_Weights` below for more details and possible values. |
|
By default, no pretrained weights are used. |
|
progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True. |
|
**kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or |
|
``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code |
|
<https://github.com/pytorch/vision/blob/main/torchvision/models/regnet.py>`_ |
|
for more detail about the classes. |
|
|
|
.. autoclass:: torchvision.models.RegNet_X_800MF_Weights |
|
:members: |
|
""" |
|
weights = RegNet_X_800MF_Weights.verify(weights) |
|
|
|
params = BlockParams.from_init_params(depth=16, w_0=56, w_a=35.73, w_m=2.28, group_width=16, **kwargs) |
|
return _regnet(params, weights, progress, **kwargs) |
|
|
|
|
|
@register_model() |
|
@handle_legacy_interface(weights=("pretrained", RegNet_X_1_6GF_Weights.IMAGENET1K_V1)) |
|
def regnet_x_1_6gf(*, weights: Optional[RegNet_X_1_6GF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet: |
|
""" |
|
Constructs a RegNetX_1.6GF architecture from |
|
`Designing Network Design Spaces <https://arxiv.org/abs/2003.13678>`_. |
|
|
|
Args: |
|
weights (:class:`~torchvision.models.RegNet_X_1_6GF_Weights`, optional): The pretrained weights to use. |
|
See :class:`~torchvision.models.RegNet_X_1_6GF_Weights` below for more details and possible values. |
|
By default, no pretrained weights are used. |
|
progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True. |
|
**kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or |
|
``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code |
|
<https://github.com/pytorch/vision/blob/main/torchvision/models/regnet.py>`_ |
|
for more detail about the classes. |
|
|
|
.. autoclass:: torchvision.models.RegNet_X_1_6GF_Weights |
|
:members: |
|
""" |
|
weights = RegNet_X_1_6GF_Weights.verify(weights) |
|
|
|
params = BlockParams.from_init_params(depth=18, w_0=80, w_a=34.01, w_m=2.25, group_width=24, **kwargs) |
|
return _regnet(params, weights, progress, **kwargs) |
|
|
|
|
|
@register_model() |
|
@handle_legacy_interface(weights=("pretrained", RegNet_X_3_2GF_Weights.IMAGENET1K_V1)) |
|
def regnet_x_3_2gf(*, weights: Optional[RegNet_X_3_2GF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet: |
|
""" |
|
Constructs a RegNetX_3.2GF architecture from |
|
`Designing Network Design Spaces <https://arxiv.org/abs/2003.13678>`_. |
|
|
|
Args: |
|
weights (:class:`~torchvision.models.RegNet_X_3_2GF_Weights`, optional): The pretrained weights to use. |
|
See :class:`~torchvision.models.RegNet_X_3_2GF_Weights` below for more details and possible values. |
|
By default, no pretrained weights are used. |
|
progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True. |
|
**kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or |
|
``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code |
|
<https://github.com/pytorch/vision/blob/main/torchvision/models/regnet.py>`_ |
|
for more detail about the classes. |
|
|
|
.. autoclass:: torchvision.models.RegNet_X_3_2GF_Weights |
|
:members: |
|
""" |
|
weights = RegNet_X_3_2GF_Weights.verify(weights) |
|
|
|
params = BlockParams.from_init_params(depth=25, w_0=88, w_a=26.31, w_m=2.25, group_width=48, **kwargs) |
|
return _regnet(params, weights, progress, **kwargs) |
|
|
|
|
|
@register_model() |
|
@handle_legacy_interface(weights=("pretrained", RegNet_X_8GF_Weights.IMAGENET1K_V1)) |
|
def regnet_x_8gf(*, weights: Optional[RegNet_X_8GF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet: |
|
""" |
|
Constructs a RegNetX_8GF architecture from |
|
`Designing Network Design Spaces <https://arxiv.org/abs/2003.13678>`_. |
|
|
|
Args: |
|
weights (:class:`~torchvision.models.RegNet_X_8GF_Weights`, optional): The pretrained weights to use. |
|
See :class:`~torchvision.models.RegNet_X_8GF_Weights` below for more details and possible values. |
|
By default, no pretrained weights are used. |
|
progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True. |
|
**kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or |
|
``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code |
|
<https://github.com/pytorch/vision/blob/main/torchvision/models/regnet.py>`_ |
|
for more detail about the classes. |
|
|
|
.. autoclass:: torchvision.models.RegNet_X_8GF_Weights |
|
:members: |
|
""" |
|
weights = RegNet_X_8GF_Weights.verify(weights) |
|
|
|
params = BlockParams.from_init_params(depth=23, w_0=80, w_a=49.56, w_m=2.88, group_width=120, **kwargs) |
|
return _regnet(params, weights, progress, **kwargs) |
|
|
|
|
|
@register_model() |
|
@handle_legacy_interface(weights=("pretrained", RegNet_X_16GF_Weights.IMAGENET1K_V1)) |
|
def regnet_x_16gf(*, weights: Optional[RegNet_X_16GF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet: |
|
""" |
|
Constructs a RegNetX_16GF architecture from |
|
`Designing Network Design Spaces <https://arxiv.org/abs/2003.13678>`_. |
|
|
|
Args: |
|
weights (:class:`~torchvision.models.RegNet_X_16GF_Weights`, optional): The pretrained weights to use. |
|
See :class:`~torchvision.models.RegNet_X_16GF_Weights` below for more details and possible values. |
|
By default, no pretrained weights are used. |
|
progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True. |
|
**kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or |
|
``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code |
|
<https://github.com/pytorch/vision/blob/main/torchvision/models/regnet.py>`_ |
|
for more detail about the classes. |
|
|
|
.. autoclass:: torchvision.models.RegNet_X_16GF_Weights |
|
:members: |
|
""" |
|
weights = RegNet_X_16GF_Weights.verify(weights) |
|
|
|
params = BlockParams.from_init_params(depth=22, w_0=216, w_a=55.59, w_m=2.1, group_width=128, **kwargs) |
|
return _regnet(params, weights, progress, **kwargs) |
|
|
|
|
|
@register_model() |
|
@handle_legacy_interface(weights=("pretrained", RegNet_X_32GF_Weights.IMAGENET1K_V1)) |
|
def regnet_x_32gf(*, weights: Optional[RegNet_X_32GF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet: |
|
""" |
|
Constructs a RegNetX_32GF architecture from |
|
`Designing Network Design Spaces <https://arxiv.org/abs/2003.13678>`_. |
|
|
|
Args: |
|
weights (:class:`~torchvision.models.RegNet_X_32GF_Weights`, optional): The pretrained weights to use. |
|
See :class:`~torchvision.models.RegNet_X_32GF_Weights` below for more details and possible values. |
|
By default, no pretrained weights are used. |
|
progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True. |
|
**kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or |
|
``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code |
|
<https://github.com/pytorch/vision/blob/main/torchvision/models/regnet.py>`_ |
|
for more detail about the classes. |
|
|
|
.. autoclass:: torchvision.models.RegNet_X_32GF_Weights |
|
:members: |
|
""" |
|
weights = RegNet_X_32GF_Weights.verify(weights) |
|
|
|
params = BlockParams.from_init_params(depth=23, w_0=320, w_a=69.86, w_m=2.0, group_width=168, **kwargs) |
|
return _regnet(params, weights, progress, **kwargs) |
|
|