def __init__(
self,
in_channels: int,
out_channels: int,
kernel_size: Union[int, Tuple],
stride: Union[int, Tuple] = 1,
dilation: Union[int, Tuple] = 1,
bias: bool = True,
) -> None:
kernel_size = _ntuple(self._ndim)(kernel_size)
stride = _ntuple(self._ndim)(stride)
dilation = _ntuple(self._ndim)(dilation)
nn.Conv2d.__init__(
self,
in_channels,
out_channels,
kernel_size,
stride=stride,
padding=_ntuple(self._ndim)(0),
dilation=dilation,
groups=1,
bias=bias,
padding_mode="zeros",
)
self.active_in_channels = in_channels
self.active_out_channels = out_channels
def _output_size(dim):
_check_size_scale_factor(dim)
if size is not None:
return size
scale_factors = _ntuple(dim)(scale_factor)
# math.floor might return float in py2.7
return [int(math.floor(input.size(i + 2) * scale_factors[i])) for i in range(dim)]
def output_shape(self):
if self.input_shape is None:
return None
scale_factor = _ntuple(len(self.input_shape) - 2)(self.scale_factor)
shape = [np.nan if s is None else s for s in self.input_shape]
return (tuple(shape[:2]) + tuple(self.size)) if self.size \
else shape[:2] + [shape[i + 2] * scale_factor[i] for i in range(len(scale_factor))]
def forward(self, x):
weight = self.weight
weight_mean = weight.mean(dim=1, keepdim=True).mean(dim=2, keepdim=True).mean(dim=3, keepdim=True)
weight = weight - weight_mean
if x.numel() > 0:
return nn.functional.conv2d(x, weight, self.bias, self.stride, self.padding, self.dilation, self.groups)
_pair = _ntuple(2)
output_shape = [
(i + 2 * p - (di * (k - 1) + 1)) // d + 1
for i, p, di, k, d in zip(
x.shape[-2:], _pair(self.padding), _pair(self.dilation), _pair(self.kernel_size), _pair(self.stride)
)
]
output_shape = [x.shape[0], self.weight.shape[0]] + output_shape
return _NewEmptyTensorOp.apply(x, output_shape)
def _output_size(dim):
_check_size_scale_factor(dim)
if size is not None:
return size
scale_factors = _ntuple(dim)(scale_factor)
# math.floor might return float in py2.7
# make scale_factor a tensor in tracing so constant doesn't get baked in
"""
if torch._C._get_tracing_state():
return [(torch.floor((input.size(i + 2) * torch.tensor(float(scale_factors[i]))).float())) for i in range(dim)]
else:
return [int(math.floor(float(input.size(i + 2)) * scale_factors[i])) for i in range(dim)]
"""
return [(torch.floor((input.size(i + 2) *
torch.tensor(float(scale_factors[i]))).float()))
for i in range(dim)]
def _output_size(dim):
_check_size_scale_factor(dim)
if size is not None:
if is_tracing:
return [torch.tensor(i) for i in size]
else:
return size
scale_factors = _ntuple(dim)(scale_factor)
# math.floor might return float in py2.7
# make scale_factor a tensor in tracing so constant doesn't get baked in
if is_tracing:
return [
(torch.floor((input.size(i + 2).float() * torch.tensor(scale_factors[i], dtype=torch.float32)).float()))
for i in range(dim)
]
else:
return [int(math.floor(float(input.size(i + 2)) * scale_factors[i])) for i in range(dim)]
def _update_long_cycle(self, runner):
"""Before every epoch, check if long cycle shape should change. If it
should, change the pipelines accordingly.
change dataloader and model's subbn3d(split_bn)
"""
base_b, base_t, base_s = self._get_schedule(runner.epoch)
# rebuild dataset
from mmaction.datasets import build_dataset
resize_list = []
for trans in self.cfg.data.train.pipeline:
if trans['type'] == 'SampleFrames':
curr_t = trans['clip_len']
trans['clip_len'] = base_t
trans['frame_interval'] = (curr_t *
trans['frame_interval']) / base_t
elif trans['type'] == 'Resize':
resize_list.append(trans)
resize_list[-1]['scale'] = _ntuple(2)(base_s)
ds = build_dataset(self.cfg.data.train)
from mmaction.datasets import build_dataloader
dataloader = build_dataloader(
ds,
self.data_cfg.videos_per_gpu * base_b,
self.data_cfg.workers_per_gpu,
dist=True,
num_gpus=len(self.cfg.gpu_ids),
drop_last=True,
seed=self.cfg.get('seed', None),
)
runner.data_loader = dataloader
self.logger.info('Rebuild runner.data_loader')
# the self._max_epochs is changed, therefore update here
runner._max_iters = runner._max_epochs * len(runner.data_loader)
# rebuild all the sub_batch_bn layers
num_modifies = modify_subbn3d_num_splits(self.logger, runner.model,
base_b)
self.logger.info(f'{num_modifies} subbns modified to {base_b}.')
def __init__(self,
depth,
num_segments=8,
is_shift=True,
non_local=(0, 0, 0, 0),
non_local_cfg=dict(),
shift_div=8,
shift_place='blockres',
temporal_pool=False,
**kwargs):
super().__init__(depth, **kwargs)
self.num_segments = num_segments
self.is_shift = is_shift
self.shift_div = shift_div
self.shift_place = shift_place
self.temporal_pool = temporal_pool
self.non_local = non_local
self.non_local_stages = _ntuple(self.num_stages)(non_local)
self.non_local_cfg = non_local_cfg
import torch.nn as nn
import math
import torch.utils.model_zoo as model_zoo
import torch.nn.functional as F
from model.dsbn import DomainSpecificBatchNorm2d
from torch.nn.modules.conv import _ConvNd
from torch.nn.modules.utils import _ntuple
from collections import OrderedDict
import operator
from itertools import islice
_pair = _ntuple(2)
__all__ = ['resnet50dsbn', 'resnet101dsbn', 'resnet152dsbn']
model_urls = {
'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
}
def conv3x3(in_planes, out_planes, stride=1):
"""3x3 convolution with padding"""
return nn.Conv2d(in_planes,
out_planes,
kernel_size=3,
stride=stride,
def __init__(self,
depth,
pretrained,
pretrained2d=True,
in_channels=3,
num_stages=4,
base_channels=64,
out_indices=(3, ),
spatial_strides=(1, 2, 2, 2),
temporal_strides=(1, 1, 1, 1),
dilations=(1, 1, 1, 1),
conv1_kernel=(5, 7, 7),
conv1_stride_t=2,
pool1_stride_t=2,
with_pool2=True,
style='pytorch',
frozen_stages=-1,
inflate=(1, 1, 1, 1),
inflate_style='3x1x1',
conv_cfg=dict(type='Conv3d'),
norm_cfg=dict(type='BN3d', requires_grad=True),
act_cfg=dict(type='ReLU', inplace=True),
norm_eval=False,
with_cp=False,
non_local=(0, 0, 0, 0),
non_local_cfg=dict(),
zero_init_residual=True,
**kwargs):
super().__init__()
if depth not in self.arch_settings:
raise KeyError(f'invalid depth {depth} for resnet')
self.depth = depth
self.pretrained = pretrained
self.pretrained2d = pretrained2d
self.in_channels = in_channels
self.base_channels = base_channels
self.num_stages = num_stages
assert num_stages >= 1 and num_stages <= 4
self.out_indices = out_indices
assert max(out_indices) < num_stages
self.spatial_strides = spatial_strides
self.temporal_strides = temporal_strides
self.dilations = dilations
assert len(spatial_strides) == len(temporal_strides) == len(
dilations) == num_stages
self.conv1_kernel = conv1_kernel
self.conv1_stride_t = conv1_stride_t
self.pool1_stride_t = pool1_stride_t
self.with_pool2 = with_pool2
self.style = style
self.frozen_stages = frozen_stages
self.stage_inflations = _ntuple(num_stages)(inflate)
self.non_local_stages = _ntuple(num_stages)(non_local)
self.inflate_style = inflate_style
self.conv_cfg = conv_cfg
self.norm_cfg = norm_cfg
self.act_cfg = act_cfg
self.norm_eval = norm_eval
self.with_cp = with_cp
self.zero_init_residual = zero_init_residual
self.block, stage_blocks = self.arch_settings[depth]
self.stage_blocks = stage_blocks[:num_stages]
self.inplanes = self.base_channels
self.non_local_cfg = non_local_cfg
self._make_stem_layer()
self.res_layers = []
for i, num_blocks in enumerate(self.stage_blocks):
spatial_stride = spatial_strides[i]
temporal_stride = temporal_strides[i]
dilation = dilations[i]
planes = self.base_channels * 2**i
res_layer = self.make_res_layer(self.block,
self.inplanes,
planes,
num_blocks,
spatial_stride=spatial_stride,
temporal_stride=temporal_stride,
dilation=dilation,
style=self.style,
norm_cfg=self.norm_cfg,
conv_cfg=self.conv_cfg,
act_cfg=self.act_cfg,
non_local=self.non_local_stages[i],
non_local_cfg=self.non_local_cfg,
inflate=self.stage_inflations[i],
inflate_style=self.inflate_style,
with_cp=with_cp,
**kwargs)
self.inplanes = planes * self.block.expansion
layer_name = f'layer{i + 1}'
self.add_module(layer_name, res_layer)
self.res_layers.append(layer_name)
self.feat_dim = self.block.expansion * self.base_channels * 2**(
len(self.stage_blocks) - 1)
return x
keep_prob = 1 - drop_prob
# work with diff dim tensors, not just 2D ConvNets
shape = (x.shape[0],) + (1,) * (x.ndim - 1)
random_tensor = keep_prob + torch.rand(shape, dtype=x.dtype, device=x.device)
random_tensor.floor_() # binarize
output = x.div(keep_prob) * random_tensor
return output
class DropPath(nn.Module):
"""Drop paths (Stochastic Depth) per sample (when applied in main path
of residual blocks)."""
def __init__(self, drop_prob=None):
super(DropPath, self).__init__()
self.drop_prob = drop_prob
def forward(self, x):
return drop_path(x, self.drop_prob, self.training)
def extra_repr(self) -> str:
return "p={}".format(self.drop_prob)
to_1tuple = _ntuple(1)
to_2tuple = _ntuple(2)
to_3tuple = _ntuple(3)
to_4tuple = _ntuple(4)
to_ntuple = _ntuple
def __init__(self,
depth,
pretrained,
in_channels=1,
num_stages=4,
base_channels=32,
strides=(1, 2, 2, 2),
dilations=(1, 1, 1, 1),
conv1_kernel=9,
conv1_stride=1,
frozen_stages=-1,
factorize=(1, 1, 0, 0),
norm_eval=False,
with_cp=False,
conv_cfg=dict(type='Conv'),
norm_cfg=dict(type='BN2d', requires_grad=True),
act_cfg=dict(type='ReLU', inplace=True),
zero_init_residual=True):
super().__init__()
if depth not in self.arch_settings:
raise KeyError(f'invalid depth {depth} for resnet')
self.depth = depth
self.pretrained = pretrained
self.in_channels = in_channels
self.base_channels = base_channels
self.num_stages = num_stages
assert 1 <= num_stages <= 4
self.dilations = dilations
self.conv1_kernel = conv1_kernel
self.conv1_stride = conv1_stride
self.frozen_stages = frozen_stages
self.stage_factorization = _ntuple(num_stages)(factorize)
self.norm_eval = norm_eval
self.with_cp = with_cp
self.conv_cfg = conv_cfg
self.norm_cfg = norm_cfg
self.act_cfg = act_cfg
self.zero_init_residual = zero_init_residual
self.block, stage_blocks = self.arch_settings[depth]
self.stage_blocks = stage_blocks[:num_stages]
self.inplanes = self.base_channels
self._make_stem_layer()
self.res_layers = []
for i, num_blocks in enumerate(self.stage_blocks):
stride = strides[i]
dilation = dilations[i]
planes = self.base_channels * 2**i
res_layer = self.make_res_layer(
self.block,
self.inplanes,
planes,
num_blocks,
stride=stride,
dilation=dilation,
factorize=self.stage_factorization[i],
norm_cfg=self.norm_cfg,
with_cp=with_cp)
self.inplanes = planes * self.block.expansion
layer_name = f'layer{i + 1}'
self.add_module(layer_name, res_layer)
self.res_layers.append(layer_name)
self.feat_dim = self.block.expansion * self.base_channels * 2**(
len(self.stage_blocks) - 1)
def __init__(self, padding: Union[int, Tuple[int]]):
super(ReflectionPad3d, self).__init__()
self.padding = _ntuple(6)(padding)
def __init__(self,
depth,
pretrained2d=True,
in_channels=3,
num_stages=4,
base_channels=64,
spatial_strides=(1, 2, 2, 2),
temporal_strides=(1, 1, 1, 1),
dilations=(1, 1, 1, 1),
conv1_kernel=(5, 7, 7),
conv1_stride_t=2,
pool1_stride_t=2,
with_pool2=True,
frozen_stages=-1,
inflate=(1, 1, 1, 1),
inflate_style='3x1x1',
norm_eval=True,
with_checkpoint=False,
zero_init_residual=True):
super().__init__()
if depth not in self.arch_settings:
raise KeyError(f'invalid depth {depth} for resnet')
self.depth = depth
self.pretrained2d = pretrained2d
self.in_channels = in_channels
self.base_channels = base_channels
self.num_stages = num_stages
assert num_stages >= 1 and num_stages <= 4
self.spatial_strides = spatial_strides
self.temporal_strides = temporal_strides
self.dilations = dilations
assert len(spatial_strides) == len(temporal_strides) == len(
dilations) == num_stages
self.conv1_kernel = conv1_kernel
self.conv1_stride_t = conv1_stride_t
self.pool1_stride_t = pool1_stride_t
self.with_pool2 = with_pool2
self.frozen_stages = frozen_stages
self.stage_inflations = _ntuple(num_stages)(inflate)
self.inflate_style = inflate_style
self.norm_eval = norm_eval
self.with_checkpoint = with_checkpoint
self.zero_init_residual = zero_init_residual
self.log = None
self.block, stage_blocks = self.arch_settings[depth]
self.stage_blocks = stage_blocks[:num_stages]
self.inplanes = self.base_channels
self._make_stem_layer()
self.res_layers = []
for i, num_blocks in enumerate(self.stage_blocks):
spatial_stride = spatial_strides[i]
temporal_stride = temporal_strides[i]
dilation = dilations[i]
planes = self.base_channels * 2**i
res_layer = self.make_res_layer(self.block,
self.inplanes,
planes,
num_blocks,
spatial_stride=spatial_stride,
temporal_stride=temporal_stride,
dilation=dilation,
inflate=self.stage_inflations[i],
inflate_style=self.inflate_style,
with_checkpoint=with_checkpoint)
self.inplanes = planes * self.block.expansion
layer_name = f'layer{i + 1}'
self.add_module(layer_name, res_layer)
self.res_layers.append(layer_name)
self.feat_dim = self.block.expansion * self.base_channels * 2**(
len(self.stage_blocks) - 1)
def __init__(self, padding) -> None:
super(PeriodicPad3d, self).__init__()
self.padding = _ntuple(6)(padding)
