XResnet

Resnet from bags of tricks paper

source

init_cnn

def init_cnn(
    m
):

source

XResNet

def XResNet(
    block, expansion, layers, p:float=0.0, c_in:int=3, n_out:int=1000, stem_szs:tuple=(32, 32, 64), widen:float=1.0,
    sa:bool=False, act_cls:type=ReLU, ndim:int=2, ks:int=3, stride:int=2, *, groups:int=1, reduction:NoneType=None,
    nh1:NoneType=None, nh2:NoneType=None, dw:bool=False, g2:int=1, sym:bool=False,
    norm_type:fastai.layers.NormType=<NormType.Batch: 1>, pool:function=AvgPool, pool_first:bool=True,
    padding:NoneType=None, bias:NoneType=None, bn_1st:bool=True, transpose:bool=False, init:str='auto',
    xtra:NoneType=None, bias_std:float=0.01, dilation:Union[int, tuple[int, int]]=1,
    padding_mode:Literal['zeros', 'reflect', 'replicate', 'circular']='zeros', device:NoneType=None,
    dtype:NoneType=None
):

A sequential container.

Modules will be added to it in the order they are passed in the constructor. Alternatively, an OrderedDict of modules can be passed in. The forward() method of Sequential accepts any input and forwards it to the first module it contains. It then “chains” outputs to inputs sequentially for each subsequent module, finally returning the output of the last module.

The value a Sequential provides over manually calling a sequence of modules is that it allows treating the whole container as a single module, such that performing a transformation on the Sequential applies to each of the modules it stores (which are each a registered submodule of the Sequential).

What’s the difference between a Sequential and a :class:torch.nn.ModuleList? A ModuleList is exactly what it sounds like–a list for storing [Module](https://docs.fast.ai/torch_core.html#module) s! On the other hand, the layers in a Sequential are connected in a cascading way.

Example::

# Using Sequential to create a small model. When `model` is run,
# input will first be passed to `Conv2d(1,20,5)`. The output of
# `Conv2d(1,20,5)` will be used as the input to the first
# `ReLU`; the output of the first `ReLU` will become the input
# for `Conv2d(20,64,5)`. Finally, the output of
# `Conv2d(20,64,5)` will be used as input to the second `ReLU`
model = nn.Sequential(
    nn.Conv2d(1, 20, 5), nn.ReLU(), nn.Conv2d(20, 64, 5), nn.ReLU()
)

# Using Sequential with OrderedDict. This is functionally the
# same as the above code
model = nn.Sequential(
    OrderedDict(
        [
            ("conv1", nn.Conv2d(1, 20, 5)),
            ("relu1", nn.ReLU()),
            ("conv2", nn.Conv2d(20, 64, 5)),
            ("relu2", nn.ReLU()),
        ]
    )
)

source

xresnet50_deeper

def xresnet50_deeper(
    pretrained:bool=False, **kwargs
):

source

xresnet34_deeper

def xresnet34_deeper(
    pretrained:bool=False, **kwargs
):

source

xresnet18_deeper

def xresnet18_deeper(
    pretrained:bool=False, **kwargs
):

source

xresnet50_deep

def xresnet50_deep(
    pretrained:bool=False, **kwargs
):

source

xresnet34_deep

def xresnet34_deep(
    pretrained:bool=False, **kwargs
):

source

xresnet18_deep

def xresnet18_deep(
    pretrained:bool=False, **kwargs
):

source

xresnet152

def xresnet152(
    pretrained:bool=False, **kwargs
):

source

xresnet101

def xresnet101(
    pretrained:bool=False, **kwargs
):

source

xresnet50

def xresnet50(
    pretrained:bool=False, **kwargs
):

source

xresnet34

def xresnet34(
    pretrained:bool=False, **kwargs
):

source

xresnet18

def xresnet18(
    pretrained:bool=False, **kwargs
):

source

xse_resnext50_deeper

def xse_resnext50_deeper(
    n_out:int=1000, pretrained:bool=False, **kwargs
):

source

xse_resnext34_deeper

def xse_resnext34_deeper(
    n_out:int=1000, pretrained:bool=False, **kwargs
):

source

xse_resnext18_deeper

def xse_resnext18_deeper(
    n_out:int=1000, pretrained:bool=False, **kwargs
):

source

xse_resnext50_deep

def xse_resnext50_deep(
    n_out:int=1000, pretrained:bool=False, **kwargs
):

source

xse_resnext34_deep

def xse_resnext34_deep(
    n_out:int=1000, pretrained:bool=False, **kwargs
):

source

xse_resnext18_deep

def xse_resnext18_deep(
    n_out:int=1000, pretrained:bool=False, **kwargs
):

source

xsenet154

def xsenet154(
    n_out:int=1000, pretrained:bool=False, **kwargs
):

source

xse_resnet152

def xse_resnet152(
    n_out:int=1000, pretrained:bool=False, **kwargs
):

source

xresnext101

def xresnext101(
    n_out:int=1000, pretrained:bool=False, **kwargs
):

source

xse_resnext101

def xse_resnext101(
    n_out:int=1000, pretrained:bool=False, **kwargs
):

source

xse_resnet101

def xse_resnet101(
    n_out:int=1000, pretrained:bool=False, **kwargs
):

source

xresnext50

def xresnext50(
    n_out:int=1000, pretrained:bool=False, **kwargs
):

source

xse_resnext50

def xse_resnext50(
    n_out:int=1000, pretrained:bool=False, **kwargs
):

source

xse_resnet50

def xse_resnet50(
    n_out:int=1000, pretrained:bool=False, **kwargs
):

source

xresnext34

def xresnext34(
    n_out:int=1000, pretrained:bool=False, **kwargs
):

source

xse_resnext34

def xse_resnext34(
    n_out:int=1000, pretrained:bool=False, **kwargs
):

source

xse_resnet34

def xse_resnet34(
    n_out:int=1000, pretrained:bool=False, **kwargs
):

source

xresnext18

def xresnext18(
    n_out:int=1000, pretrained:bool=False, **kwargs
):

source

xse_resnext18

def xse_resnext18(
    n_out:int=1000, pretrained:bool=False, **kwargs
):

source

xse_resnet18

def xse_resnet18(
    n_out:int=1000, pretrained:bool=False, **kwargs
):
tst = xse_resnext18()
x = torch.randn(64, 3, 128, 128)
y = tst(x)
tst = xresnext18()
x = torch.randn(64, 3, 128, 128)
y = tst(x)
tst = xse_resnet50()
x = torch.randn(8, 3, 64, 64)
y = tst(x)
tst = xresnet18(ndim=1, c_in=1, ks=15)
x = torch.randn(64, 1, 128)
y = tst(x)
tst = xresnext50(ndim=1, c_in=2, ks=31, stride=4)
x = torch.randn(8, 2, 128)
y = tst(x)
tst = xresnet18(ndim=3, c_in=3, ks=3)
x = torch.randn(8, 3, 32, 32, 32)
y = tst(x)