def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True):
kernel_size = _pair(kernel_size)
stride = _pair(stride)
padding = _pair(padding)
dilation = _pair(dilation)
super(SNConv2d, self).__init__(
in_channels, out_channels, kernel_size, stride, padding, dilation,
False, _pair(0), groups, bias)
def avg_pool2d(g, input, kernel_size, stride, padding, ceil_mode, count_include_pad):
if ceil_mode:
return _unimplemented("avg_pool2d", "ceil_mode")
if not stride:
stride = kernel_size
# TODO: What about count_include_pad?!
return g.op("AveragePool", input,
kernel_shape_i=_pair(kernel_size),
strides_i=_pair(stride),
pads_i=_pair(padding) * 2)
def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True,
cuda=False, init_weight=None, init_bias=None, clip_var=None):
kernel_size = utils._pair(kernel_size)
stride = utils._pair(stride)
padding = utils._pair(padding)
dilation = utils._pair(dilation)
super(Conv2dGroupNJ, self).__init__(
in_channels, out_channels, kernel_size, stride, padding, dilation,
False, utils._pair(0), groups, bias, init_weight, init_bias, cuda, clip_var)
def max_pool2d(g, input, kernel_size, stride, padding, dilation, ceil_mode):
if ceil_mode:
return _unimplemented("max_pool2d", "ceil_mode")
if set(_pair(dilation)) != {1}:
return _unimplemented("max_pool2d", "dilation")
if not stride:
stride = kernel_size
r = g.op("MaxPool", input,
kernel_shape_i=_pair(kernel_size),
pads_i=_pair(padding) * 2,
strides_i=_pair(stride))
return r, None
def forward(ctx, input, roi, output_size, spatial_scale):
ctx.output_size = _pair(output_size)
ctx.spatial_scale = spatial_scale
ctx.input_shape = input.size()
output, argmax = _C.roi_pool_forward(input, roi, spatial_scale,
output_size[0], output_size[1])
ctx.save_for_backward(input, roi, argmax)
return output
def forward(ctx, input, kernel_size, stride=None, padding=0, dilation=1, ceil_mode=False):
ctx.kernel_size = _pair(kernel_size)
ctx.stride = _pair(stride if stride is not None else kernel_size)
ctx.padding = _pair(padding)
ctx.dilation = _pair(dilation)
ctx.ceil_mode = ceil_mode
backend = type2backend[type(input)]
indices, output = input.new().long(), input.new()
backend.SpatialDilatedMaxPooling_updateOutput(backend.library_state,
input, output, indices,
ctx.kernel_size[1], ctx.kernel_size[0],
ctx.stride[1], ctx.stride[0],
ctx.padding[1], ctx.padding[0],
ctx.dilation[1], ctx.dilation[0],
ctx.ceil_mode)
ctx.save_for_backward(input, indices)
ctx.mark_non_differentiable(indices)
return output, indices
def forward(ctx, input, roi, output_size, spatial_scale, sampling_ratio):
ctx.save_for_backward(roi)
ctx.output_size = _pair(output_size)
ctx.spatial_scale = spatial_scale
ctx.sampling_ratio = sampling_ratio
ctx.input_shape = input.size()
output = _C.roi_align_forward(
input, roi, spatial_scale, output_size[0], output_size[1], sampling_ratio
)
return output
def forward(ctx, input, kernel_size, stride=None, padding=0,
ceil_mode=False, count_include_pad=True):
ctx.kernel_size = _pair(kernel_size)
ctx.stride = _pair(stride if stride is not None else kernel_size)
ctx.padding = _pair(padding)
ctx.ceil_mode = ceil_mode
ctx.count_include_pad = count_include_pad
backend = type2backend[type(input)]
output = input.new()
# can avoid this with cudnn
ctx.save_for_backward(input)
backend.SpatialAveragePooling_updateOutput(
backend.library_state,
input, output,
ctx.kernel_size[1], ctx.kernel_size[0],
ctx.stride[1], ctx.stride[0],
ctx.padding[1], ctx.padding[0],
ctx.ceil_mode, ctx.count_include_pad)
return output
def forward(ctx, input, output_size):
ctx.output_size = _pair(output_size)
backend = type2backend[type(input)]
output = input.new()
ctx.save_for_backward(input)
backend.SpatialAdaptiveAveragePooling_updateOutput(
backend.library_state,
input, output,
ctx.output_size[1], ctx.output_size[0])
return output
def forward(ctx, input, output_size):
ctx.output_size = list(_pair(output_size))
for i, s in enumerate(ctx.output_size):
ctx.output_size[i] = ctx.output_size[i] or input.size(i + 2)
ctx.output_size = tuple(ctx.output_size)
backend = type2backend[type(input)]
indices, output = input.new().long(), input.new()
backend.SpatialAdaptiveMaxPooling_updateOutput(backend.library_state,
input, output, indices,
ctx.output_size[1], ctx.output_size[0])
ctx.save_for_backward(input, indices)
ctx.mark_non_differentiable(indices)
return output, indices
def forward(ctx, input, output_size):
ctx.output_size = list(_pair(output_size))
for i, s in enumerate(ctx.output_size):
ctx.output_size[i] = ctx.output_size[i] or input.size(i + 2)
ctx.output_size = tuple(ctx.output_size)
backend = type2backend[type(input)]
output = input.new()
ctx.save_for_backward(input)
backend.SpatialAdaptiveAveragePooling_updateOutput(
backend.library_state,
input, output,
ctx.output_size[1], ctx.output_size[0])
return output
def forward(ctx, input, output_size, return_indices=False):
ctx.output_size = _pair(output_size)
ctx.return_indices = return_indices
backend = type2backend[type(input)]
indices, output = input.new().long(), input.new()
backend.SpatialAdaptiveMaxPooling_updateOutput(backend.library_state,
input, output, indices,
ctx.output_size[1], ctx.output_size[0])
if ctx.return_indices:
ctx.save_for_backward(input, indices)
ctx.mark_non_differentiable(indices)
return output, indices
else:
ctx.save_for_backward(input)
ctx.indices = indices
return output
def deform_conv2d(input,
offset,
weight,
bias=None,
stride=(1, 1),
padding=(0, 0),
dilation=(1, 1)):
# type: (Tensor, Tensor, Tensor, Optional[Tensor], Tuple[int, int], Tuple[int, int], Tuple[int, int]) -> Tensor
"""
Performs Deformable Convolution, described in Deformable Convolutional Networks
Arguments:
input (Tensor[batch_size, in_channels, in_height, in_width]): input tensor
offset (Tensor[batch_size, 2 * offset_groups * kernel_height * kernel_width,
out_height, out_width]): offsets to be applied for each position in the
convolution kernel.
weight (Tensor[out_channels, in_channels // groups, kernel_height, kernel_width]):
convolution weights, split into groups of size (in_channels // groups)
bias (Tensor[out_channels]): optional bias of shape (out_channels,). Default: None
stride (int or Tuple[int, int]): distance between convolution centers. Default: 1
padding (int or Tuple[int, int]): height/width of padding of zeroes around
each image. Default: 0
dilation (int or Tuple[int, int]): the spacing between kernel elements. Default: 1
Returns:
output (Tensor[batch_sz, out_channels, out_h, out_w]): result of convolution
Examples::
>>> input = torch.rand(1, 3, 10, 10)
>>> kh, kw = 3, 3
>>> weight = torch.rand(5, 3, kh, kw)
>>> # offset should have the same spatial size as the output
>>> # of the convolution. In this case, for an input of 10, stride of 1
>>> # and kernel size of 3, without padding, the output size is 8
>>> offset = torch.rand(5, 2 * kh * kw, 8, 8)
>>> out = deform_conv2d(input, offset, weight)
>>> print(out.shape)
>>> # returns
>>> torch.Size([1, 5, 8, 8])
"""
out_channels = weight.shape[0]
if bias is None:
bias = torch.zeros(out_channels,
device=input.device,
dtype=input.dtype)
stride_h, stride_w = _pair(stride)
pad_h, pad_w = _pair(padding)
dil_h, dil_w = _pair(dilation)
weights_h, weights_w = weight.shape[-2:]
_, n_in_channels, in_h, in_w = input.shape
n_offset_grps = offset.shape[1] // (2 * weights_h * weights_w)
n_weight_grps = n_in_channels // weight.shape[1]
if n_offset_grps == 0:
raise RuntimeError(
"the shape of the offset tensor at dimension 1 is not valid. It should "
"be a multiple of 2 * weight.size[2] * weight.size[3].\n"
"Got offset.shape[1]={}, while 2 * weight.size[2] * weight.size[3]={}"
.format(offset.shape[1], 2 * weights_h * weights_w))
return torch.ops.torchvision.deform_conv2d(input, weight, offset, bias,
stride_h, stride_w, pad_h,
pad_w, dil_h, dil_w,
n_weight_grps, n_offset_grps)
def __init__(self,
num_convs=4,
roi_feat_size=14,
in_channels=256,
conv_kernel_size=3,
conv_out_channels=256,
upsample_method='deconv',
upsample_ratio=2,
num_upsamples=1,
num_classes=81,
class_agnostic=False,
upsample_cfg=None,
conv_cfg=None,
norm_cfg=None,
loss_mask=dict(type='CrossEntropyLoss',
use_mask=True,
loss_weight=1.0)):
super(FCNMaskHead, self).__init__()
if upsample_method not in [
None, 'deconv', 'nearest', 'bilinear', 'carafe'
]:
raise ValueError(
'Invalid upsample method {}, accepted methods '
'are "deconv", "nearest", "bilinear", "carafe"'.format(
upsample_method))
if upsample_method == 'carafe':
assert upsample_cfg is not None
self.upsample_cfg = upsample_cfg
self.num_convs = num_convs
# WARN: roi_feat_size is reserved and not used
self.roi_feat_size = _pair(roi_feat_size)
self.in_channels = in_channels
self.conv_kernel_size = conv_kernel_size
self.conv_out_channels = conv_out_channels
self.upsample_method = upsample_method
self.upsample_ratio = upsample_ratio
self.num_classes = num_classes
self.class_agnostic = class_agnostic
self.conv_cfg = conv_cfg
self.norm_cfg = norm_cfg
self.fp16_enabled = False
self.loss_mask = build_loss(loss_mask)
self.num_upsamples = num_upsamples
self.convs = nn.ModuleList()
for i in range(self.num_convs):
in_channels = (self.in_channels
if i == 0 else self.conv_out_channels)
padding = (self.conv_kernel_size - 1) // 2
self.convs.append(
ConvModule(in_channels,
self.conv_out_channels,
self.conv_kernel_size,
padding=padding,
conv_cfg=conv_cfg,
norm_cfg=norm_cfg))
upsample_in_channels = (self.conv_out_channels
if self.num_convs > 0 else in_channels)
if self.upsample_method is None:
self.upsample = None
elif self.upsample_method == 'deconv':
self.upsample = nn.ModuleList()
for i in range(self.num_upsamples):
# upsample_in_channels = (
# self.upsample_in_channels if i == 0 else self.conv_out_channels)
self.upsample.append(
nn.ConvTranspose2d(upsample_in_channels,
self.conv_out_channels,
self.upsample_ratio,
stride=self.upsample_ratio))
elif self.upsample_method == 'carafe':
self.upsample = CARAFEPack(upsample_in_channels,
self.upsample_ratio,
**self.upsample_cfg)
else:
self.upsample = nn.ModuleList()
for i in range(self.num_upsamples):
self.upsample.append(
nn.Upsample(scale_factor=self.upsample_ratio,
mode=self.upsample_method))
out_channels = 1 if self.class_agnostic else self.num_classes
logits_in_channel = (self.conv_out_channels if self.upsample_method
== 'deconv' else upsample_in_channels)
self.conv_logits = nn.Conv2d(logits_in_channel, out_channels, 1)
self.relu = nn.ReLU(inplace=True)
self.debug_imgs = None
def conv2d_config(in_shape, out_shape, kernel_size, stride=None):
"""
Given desired input and output tensor shapes and convolution kernel size,
returns configurations that can be used to construct an appropriate 2D
convolution operation satisfying the desired properties.
Args:
in_shape: shape of the input tensor. May be either [batch, channel, height, width]
or [channel, height, width]
out_shape: shape of the output tensor. May be either [batch, channel, height, width]
or [channel, height, width]
kernel_size: shape of the kernel. May be an integer or a pair tuple
stride: (OPTIONAL) desired stride to be used. If not provided, optimal stride size
will be computed and returned to minimize the necessary amount of padding
or stripping.
Returns:
A tuple (stride, padding, output_padding, padded_shape, conv_type, padding_type).
stride: optimial stride size to be used. If stride was passed in, no change is made.
padding: padding to be applied to each edge
output_padding: if operation is transpose convolution, supplies output_padding that's
necessary. Otherwise, this is None.
conv_type: the required type of convolution. It is either "NORMAL" or "TRANSPOSE"
padding_type: string to indicate the type of padding. Either "VALID" or "SAME".
"""
in_shape = np.array(in_shape[-3:])
out_shape = np.array(out_shape[-3:])
kern_shape = np.array(kernel_size)
# determine the kind of convolution to use
if np.all(in_shape[-2:] >= out_shape[-2:]):
conv_type = "NORMAL"
elif np.all(in_shape[-2:] <= out_shape[-2:]):
conv_type = "TRANSPOSE"
in_shape, out_shape = out_shape, in_shape
else:
raise ValueError('Input shape dimensions must be both >= OR <= the output shape dimensions')
if stride is None:
stride = np.ceil((in_shape[-2:] - kern_shape + 1) / (out_shape[-2:] - 1)).astype(np.int)
else:
stride = np.array(_pair(stride))
stride[stride <= 0] = 1
padding = (out_shape[-2:] - 1) * stride + kern_shape - in_shape[-2:]
if np.all(np.ceil(in_shape[-2:] / stride) == out_shape[-2:]):
padding_type = 'SAME'
else:
padding_type = 'VALID'
# get padded input shape
in_shape[-2:] = in_shape[-2:] + padding.astype(np.int)
padded_shape = tuple(in_shape.tolist())
if conv_type == "TRANSPOSE":
output_padding = tuple((padding % 2 != 0).astype(np.int).tolist())
else:
output_padding = None
padding = tuple(np.ceil(padding / 2).astype(np.int).tolist())
stride = tuple(stride.tolist())
return stride, padding, output_padding, \
padded_shape, conv_type, padding_type
def __init__(self, kernel_size, stride=1, padding=0):
super(AvgPool2d, self).__init__(_pair(kernel_size), 'avg', _pair(stride), _pair(padding))
def __init__(self,
num_convs=4,
roi_feat_size=14,
in_channels=256,
conv_kernel_size=3,
conv_out_channels=256,
num_classes=81,
class_agnostic=False,
upsample_cfg=dict(type='deconv', scale_factor=2),
conv_cfg=None,
norm_cfg=None,
loss_mask=dict(type='CrossEntropyLoss',
use_mask=True,
loss_weight=1.0)):
super(FCNMaskHead, self).__init__()
self.upsample_cfg = upsample_cfg.copy()
if self.upsample_cfg['type'] not in [
None, 'deconv', 'nearest', 'bilinear', 'carafe'
]:
raise ValueError(
'Invalid upsample method {}, accepted methods '
'are "deconv", "nearest", "bilinear", "carafe"'.format(
self.upsample_cfg['type']))
self.num_convs = num_convs
# WARN: roi_feat_size is reserved and not used
self.roi_feat_size = _pair(roi_feat_size)
self.in_channels = in_channels
self.conv_kernel_size = conv_kernel_size
self.conv_out_channels = conv_out_channels
self.upsample_method = self.upsample_cfg.get('type')
self.scale_factor = self.upsample_cfg.pop('scale_factor')
self.num_classes = num_classes
self.class_agnostic = class_agnostic
self.conv_cfg = conv_cfg
self.norm_cfg = norm_cfg
self.fp16_enabled = False
self.loss_mask = build_loss(loss_mask)
self.convs = nn.ModuleList()
for i in range(self.num_convs):
in_channels = (self.in_channels
if i == 0 else self.conv_out_channels)
padding = (self.conv_kernel_size - 1) // 2
self.convs.append(
ConvModule(in_channels,
self.conv_out_channels,
self.conv_kernel_size,
padding=padding,
conv_cfg=conv_cfg,
norm_cfg=norm_cfg))
upsample_in_channels = (self.conv_out_channels
if self.num_convs > 0 else in_channels)
upsample_cfg_ = self.upsample_cfg.copy()
if self.upsample_method is None:
self.upsample = None
elif self.upsample_method == 'deconv':
upsample_cfg_.update(in_channels=upsample_in_channels,
out_channels=self.conv_out_channels,
kernel_size=self.scale_factor,
stride=self.scale_factor)
elif self.upsample_method == 'carafe':
upsample_cfg_.update(channels=upsample_in_channels,
scale_factor=self.scale_factor)
else:
# suppress warnings
align_corners = (None
if self.upsample_method == 'nearest' else False)
upsample_cfg_.update(scale_factor=self.scale_factor,
mode=self.upsample_method,
align_corners=align_corners)
self.upsample = build_upsample_layer(upsample_cfg_)
out_channels = 1 if self.class_agnostic else self.num_classes
logits_in_channel = (self.conv_out_channels if self.upsample_method
== 'deconv' else upsample_in_channels)
self.conv_logits = nn.Conv2d(logits_in_channel, out_channels, 1)
self.relu = nn.ReLU(inplace=True)
self.debug_imgs = None
def __init__(self,
with_avg_pool=False,
with_cls=True,
with_reg=True,
roi_feat_size=7,
in_channels=[256, 512, 1024],
anchors=[[10, 13], [16, 30], [33, 23], [30, 61], [62, 45],
[59, 119], [116, 90], [156, 198], [373, 326]],
num_classes=80,
input_size=416,
target_means=[0., 0., 0., 0.],
target_stds=[0.1, 0.1, 0.2, 0.2],
reg_class_agnostic=False,
loss_cls=dict(type='CrossEntropyLoss',
use_sigmoid=False,
loss_weight=1.0),
loss_bbox=dict(type='SmoothL1Loss', beta=1.0,
loss_weight=1.0)):
super(YoloHead, self).__init__()
assert with_cls or with_reg
self.with_avg_pool = with_avg_pool
self.with_cls = with_cls
self.with_reg = with_reg
self.roi_feat_size = _pair(roi_feat_size)
self.roi_feat_area = self.roi_feat_size[0] * self.roi_feat_size[1]
self.in_channels = in_channels
self.num_classes = num_classes
self.target_means = target_means
self.target_stds = target_stds
self.reg_class_agnostic = reg_class_agnostic
self.fp16_enabled = False
self.input_size = input_size
self.grid_size = [
int(input_size / 8),
int(input_size / 16),
int(input_size / 32)
]
self.anchors = anchors
in_channels = self.in_channels
self.head_layers = []
for i in range(len(in_channels)):
numIn = int(in_channels[i])
# if numIn != 1024:
# numIn = numIn + int(numIn / 2)
numOut = int(numIn / 2)
numOut2 = 3 * (self.num_classes - 1 + 5)
if numIn != 1024:
up = nn.Sequential(
DarknetConv2D_BN_Leaky(numIn,
numOut,
ksize=1,
stride=1,
padding=0),
Upsample(scale_factor=2))
last = LastLayer(numIn + numOut, numOut, numOut2)
up_name = 'up{}'.format(i + 1)
self.add_module(up_name, up)
last_name = 'last{}'.format(i + 1)
self.add_module(last_name, last)
self.head_layers.append([up_name, last_name])
else:
last = LastLayer(numIn, numOut, numOut2)
last_name = 'last{}'.format(i + 1)
self.add_module(last_name, last)
self.head_layers.append(last_name)
def max_pool2d(input, kernel_size: Vector, stride: Vector, padding: Vector, dilation: Vector, ceil_mode: bool):
if len(_pair(stride)) == 0:
stride = kernel_size
return torch.ops.torch_ipex.max_pool2d(input, _pair(kernel_size), _pair(stride), _pair(padding), _pair(dilation), ceil_mode)
"""Split-Attention"""
def __init__(self, kernel_size=3, stride=1, padding=0, same=False):
super(MedianPool2d, self).__init__()
self.k = _pair(kernel_size)
self.stride = _pair(stride)
self.padding = _quadruple(padding) # convert to l, r, t, b
self.same = same
def __init__(self,
num_convs=4,
roi_feat_size=14,
in_channels=256,
conv_kernel_size=3,
conv_out_channels=256,
upsample_method='deconv',
upsample_ratio=2,
num_classes=81,
class_agnostic=False,
conv_cfg=None,
norm_cfg=None,
loss_mask=dict(type='CrossEntropyLoss',
use_mask=True,
loss_weight=1.0)):
super(FCNMaskHead, self).__init__()
if upsample_method not in [None, 'deconv', 'nearest', 'bilinear']:
raise ValueError(
'Invalid upsample method {}, accepted methods '
'are "deconv", "nearest", "bilinear"'.format(upsample_method))
self.num_convs = num_convs
# WARN: roi_feat_size is reserved and not used
self.roi_feat_size = _pair(roi_feat_size)
self.in_channels = in_channels
self.conv_kernel_size = conv_kernel_size
self.conv_out_channels = conv_out_channels
self.upsample_method = upsample_method
self.upsample_ratio = upsample_ratio
self.num_classes = num_classes
self.class_agnostic = class_agnostic
self.conv_cfg = conv_cfg
self.norm_cfg = norm_cfg
self.fp16_enabled = False
self.loss_mask = build_loss(loss_mask)
self.convs = nn.ModuleList()
for i in range(self.num_convs):
in_channels = (self.in_channels
if i == 0 else self.conv_out_channels)
padding = (self.conv_kernel_size - 1) // 2
self.convs.append(
ConvModule(in_channels,
self.conv_out_channels,
self.conv_kernel_size,
padding=padding,
conv_cfg=conv_cfg,
norm_cfg=norm_cfg))
upsample_in_channels = (self.conv_out_channels
if self.num_convs > 0 else in_channels)
if self.upsample_method is None:
self.upsample = None
elif self.upsample_method == 'deconv':
self.upsample = nn.ConvTranspose2d(upsample_in_channels,
self.conv_out_channels,
self.upsample_ratio,
stride=self.upsample_ratio)
else:
self.upsample = nn.Upsample(scale_factor=self.upsample_ratio,
mode=self.upsample_method)
out_channels = 1 if self.class_agnostic else self.num_classes
logits_in_channel = (self.conv_out_channels if self.upsample_method
== 'deconv' else upsample_in_channels)
# each binary mask is corresponding to a class (exclude background) in origin paper.
# but in most implement, background is included even the 0-th dim is discharged.
self.conv_logits = nn.Conv2d(logits_in_channel, out_channels, 1)
self.relu = nn.ReLU(inplace=True)
self.debug_imgs = None
def plot_locally_connected_weights(
weights: torch.Tensor,
n_filters: int,
kernel_size: Union[int, Tuple[int, int]],
conv_size: Union[int, Tuple[int, int]],
locations: torch.Tensor,
input_sqrt: Union[int, Tuple[int, int]],
wmin: float = 0.0,
wmax: float = 1.0,
im: Optional[AxesImage] = None,
lines: bool = True,
figsize: Tuple[int, int] = (5, 5),
cmap: str = "hot_r",
) -> AxesImage:
# language=rst
"""
Plot a connection weight matrix of a :code:`Connection` with `locally connected
structure <http://yann.lecun.com/exdb/publis/pdf/gregor-nips-11.pdf>_.
:param weights: Weight matrix of Conv2dConnection object.
:param n_filters: No. of convolution kernels in use.
:param kernel_size: Side length(s) of 2D convolution kernels.
:param conv_size: Side length(s) of 2D convolution population.
:param locations: Indices of input receptive fields for convolution population
neurons.
:param input_sqrt: Side length(s) of 2D input data.
:param wmin: Minimum allowed weight value.
:param wmax: Maximum allowed weight value.
:param im: Used for re-drawing the weights plot.
:param lines: Whether or not to draw horizontal and vertical lines separating input
regions.
:param figsize: Horizontal, vertical figure size in inches.
:param cmap: Matplotlib colormap.
:return: Used for re-drawing the weights plot.
"""
kernel_size = _pair(kernel_size)
conv_size = _pair(conv_size)
input_sqrt = _pair(input_sqrt)
reshaped = reshape_locally_connected_weights(
weights, n_filters, kernel_size, conv_size, locations, input_sqrt
)
n_sqrt = int(np.ceil(np.sqrt(n_filters)))
if not im:
fig, ax = plt.subplots(figsize=figsize)
im = ax.imshow(reshaped.cpu(), cmap=cmap, vmin=wmin, vmax=wmax)
div = make_axes_locatable(ax)
cax = div.append_axes("right", size="5%", pad=0.05)
if lines:
for i in range(
n_sqrt * kernel_size[0],
n_sqrt * conv_size[0] * kernel_size[0],
n_sqrt * kernel_size[0],
):
ax.axhline(i - 0.5, color="g", linestyle="--")
for i in range(
n_sqrt * kernel_size[1],
n_sqrt * conv_size[1] * kernel_size[1],
n_sqrt * kernel_size[1],
):
ax.axvline(i - 0.5, color="g", linestyle="--")
ax.set_xticks(())
ax.set_yticks(())
ax.set_aspect("auto")
plt.colorbar(im, cax=cax)
fig.tight_layout()
else:
im.set_data(reshaped)
return im
def __init__(self, in_channels, out_channels, kernel_size=1, stride=1,
padding=0, dilation=1, groups=1, bias=False):
"""
:param in_channels:
:param out_channels:
:param kernel_size:
:param stride:
:param padding:
:param dilation:
:param groups:
:param bias:
"""
kernel_size = _pair(kernel_size)
stride = _pair(stride)
padding = _pair(padding)
dilation = _pair(dilation)
super(HighFrequencyGatedSpatialConv2d, self).__init__(
in_channels, out_channels, kernel_size, stride, padding, dilation,
False, _pair(0), groups, bias)
self._gate_conv = nn.Sequential(
mynn.Norm2d(in_channels+1),
nn.Conv2d(in_channels+1, in_channels+1, 1),
nn.ReLU(),
nn.Conv2d(in_channels+1, 1, 1),
mynn.Norm2d(1),
nn.Sigmoid()
)
kernel_size = 7
sigma = 3
x_cord = torch.arange(kernel_size).float()
x_grid = x_cord.repeat(kernel_size).view(kernel_size, kernel_size).float()
y_grid = x_grid.t().float()
xy_grid = torch.stack([x_grid, y_grid], dim=-1).float()
mean = (kernel_size - 1)/2.
variance = sigma**2.
gaussian_kernel = (1./(2.*math.pi*variance)) *\
torch.exp(
-torch.sum((xy_grid - mean)**2., dim=-1) /\
(2*variance)
)
gaussian_kernel = gaussian_kernel / torch.sum(gaussian_kernel)
gaussian_kernel = gaussian_kernel.view(1, 1, kernel_size, kernel_size)
gaussian_kernel = gaussian_kernel.repeat(in_channels, 1, 1, 1)
self.gaussian_filter = nn.Conv2d(in_channels=in_channels, out_channels=in_channels, padding=3,
kernel_size=kernel_size, groups=in_channels, bias=False)
self.gaussian_filter.weight.data = gaussian_kernel
self.gaussian_filter.weight.requires_grad = False
self.cw = nn.Conv2d(in_channels * 2, in_channels, 1)
self.procdog = nn.Sequential(
nn.Conv2d(in_channels, in_channels, 1),
mynn.Norm2d(in_channels),
nn.Sigmoid()
)
def _ann_to_snn_helper(prev, current, node_type, **kwargs):
# language=rst
"""
Helper function for main ``ann_to_snn`` method.
:param prev: Previous PyTorch module in artificial neural network.
:param current: Current PyTorch module in artificial neural network.
:return: Spiking neural network layer and connection corresponding to ``prev`` and ``current`` PyTorch modules.
"""
if isinstance(current, nn.Linear):
layer = node_type(n=current.out_features,
reset=0,
thresh=1,
refrac=0,
**kwargs)
bias = current.bias if current.bias is not None else torch.zeros(
layer.n)
connection = topology.Connection(source=prev,
target=layer,
w=current.weight.t(),
b=bias)
elif isinstance(current, nn.Conv2d):
input_height, input_width = prev.shape[2], prev.shape[3]
out_channels, output_height, output_width = (
current.out_channels,
prev.shape[2],
prev.shape[3],
)
width = (input_height - current.kernel_size[0] +
2 * current.padding[0]) / current.stride[0] + 1
height = (input_width - current.kernel_size[1] +
2 * current.padding[1]) / current.stride[1] + 1
shape = (1, out_channels, int(width), int(height))
layer = node_type(shape=shape, reset=0, thresh=1, refrac=0, **kwargs)
bias = current.bias if current.bias is not None else torch.zeros(
layer.shape[1])
connection = topology.Conv2dConnection(
source=prev,
target=layer,
kernel_size=current.kernel_size,
stride=current.stride,
padding=current.padding,
dilation=current.dilation,
w=current.weight,
b=bias,
)
elif isinstance(current, nn.MaxPool2d):
input_height, input_width = prev.shape[2], prev.shape[3]
current.kernel_size = _pair(current.kernel_size)
current.padding = _pair(current.padding)
current.stride = _pair(current.stride)
width = (input_height - current.kernel_size[0] +
2 * current.padding[0]) / current.stride[0] + 1
height = (input_width - current.kernel_size[1] +
2 * current.padding[1]) / current.stride[1] + 1
shape = (1, prev.shape[1], int(width), int(height))
layer = PassThroughNodes(shape=shape)
connection = topology.MaxPool2dConnection(
source=prev,
target=layer,
kernel_size=current.kernel_size,
stride=current.stride,
padding=current.padding,
dilation=current.dilation,
decay=1,
)
elif isinstance(current, Permute):
layer = PassThroughNodes(shape=[
prev.shape[current.dims[0]],
prev.shape[current.dims[1]],
prev.shape[current.dims[2]],
prev.shape[current.dims[3]],
])
connection = PermuteConnection(source=prev,
target=layer,
dims=current.dims)
elif isinstance(current, nn.ConstantPad2d):
layer = PassThroughNodes(shape=[
prev.shape[0],
prev.shape[1],
current.padding[0] + current.padding[1] + prev.shape[2],
current.padding[2] + current.padding[3] + prev.shape[3],
])
connection = ConstantPad2dConnection(source=prev,
target=layer,
padding=current.padding)
else:
return None, None
return layer, connection
def __init__(self, crop_size):
self.crop_size = _pair(crop_size)
if not mmcv.is_tuple_of(self.crop_size, int):
raise TypeError(f'Crop_size must be int or tuple of int, '
f'but got {type(crop_size)}')
def __init__(self, kernel_size, stride=None, padding=0):
super(MaxUnpool2d, self).__init__()
self.kernel_size = _pair(kernel_size)
self.stride = _pair(stride or kernel_size)
self.padding = _pair(padding)
def __init__(self,
strides,
ratios,
min_sizes=None,
max_sizes=None,
basesize_ratio_range=(0.15, 0.9),
input_size=300,
scale_major=True):
assert len(strides) == len(ratios)
assert not (min_sizes is None) ^ (max_sizes is None)
self.strides = [_pair(stride) for stride in strides]
self.centers = [(stride[0] / 2., stride[1] / 2.)
for stride in self.strides]
if min_sizes is None and max_sizes is None:
# use hard code to generate SSD anchors
self.input_size = input_size
assert mmcv.is_tuple_of(basesize_ratio_range, float)
self.basesize_ratio_range = basesize_ratio_range
# calculate anchor ratios and sizes
min_ratio, max_ratio = basesize_ratio_range
min_ratio = int(min_ratio * 100)
max_ratio = int(max_ratio * 100)
step = int(np.floor(max_ratio - min_ratio) / (self.num_levels - 2))
min_sizes = []
max_sizes = []
for ratio in range(int(min_ratio), int(max_ratio) + 1, step):
min_sizes.append(int(self.input_size * ratio / 100))
max_sizes.append(int(self.input_size * (ratio + step) / 100))
if self.input_size == 300:
if basesize_ratio_range[0] == 0.15: # SSD300 COCO
min_sizes.insert(0, int(self.input_size * 7 / 100))
max_sizes.insert(0, int(self.input_size * 15 / 100))
elif basesize_ratio_range[0] == 0.2: # SSD300 VOC
min_sizes.insert(0, int(self.input_size * 10 / 100))
max_sizes.insert(0, int(self.input_size * 20 / 100))
else:
raise ValueError(
'basesize_ratio_range[0] should be either 0.15'
'or 0.2 when input_size is 300, got '
f'{basesize_ratio_range[0]}.')
elif self.input_size == 512:
if basesize_ratio_range[0] == 0.1: # SSD512 COCO
min_sizes.insert(0, int(self.input_size * 4 / 100))
max_sizes.insert(0, int(self.input_size * 10 / 100))
elif basesize_ratio_range[0] == 0.15: # SSD512 VOC
min_sizes.insert(0, int(self.input_size * 7 / 100))
max_sizes.insert(0, int(self.input_size * 15 / 100))
else:
raise ValueError(
'When not setting min_sizes and max_sizes,'
'basesize_ratio_range[0] should be either 0.1'
'or 0.15 when input_size is 512, got'
f' {basesize_ratio_range[0]}.')
else:
raise ValueError(
'Only support 300 or 512 in SSDAnchorGenerator when '
'not setting min_sizes and max_sizes, '
f'got {self.input_size}.')
assert len(min_sizes) == len(max_sizes) == len(strides)
anchor_ratios = []
anchor_scales = []
for k in range(len(self.strides)):
scales = [1., np.sqrt(max_sizes[k] / min_sizes[k])]
anchor_ratio = [1.]
for r in ratios[k]:
anchor_ratio += [1 / r, r] # 4 or 6 ratio
anchor_ratios.append(torch.Tensor(anchor_ratio))
anchor_scales.append(torch.Tensor(scales))
self.base_sizes = min_sizes
self.scales = anchor_scales
self.ratios = anchor_ratios
self.scale_major = scale_major
self.center_offset = 0
self.base_anchors = self.gen_base_anchors()
def __init__(self,
in_channels,
channels,
kernel_size,
stride=(1, 1),
padding=(0, 0),
dilation=(1, 1),
groups=1,
bias=True,
radix=2,
reduction_factor=4,
rectify=False,
rectify_avg=False,
norm_layer=None,
dropblock_prob=0.0,
**kwargs):
super(SplAtConv2d, self).__init__()
padding = _pair(padding)
self.rectify = rectify and (padding[0] > 0 or padding[1] > 0)
self.rectify_avg = rectify_avg
inter_channels = max(in_channels * radix // reduction_factor, 32)
self.radix = radix
self.cardinality = groups
self.channels = channels
self.dropblock_prob = dropblock_prob
if self.rectify:
from rfconv import RFConv2d
self.conv = RFConv2d(in_channels,
channels * radix,
kernel_size,
stride,
padding,
dilation,
groups=groups * radix,
bias=bias,
average_mode=rectify_avg,
**kwargs)
else:
self.conv = Conv2d(in_channels,
channels * radix,
kernel_size,
stride,
padding,
dilation,
groups=groups * radix,
bias=bias,
**kwargs)
self.use_bn = norm_layer is not None
if self.use_bn:
self.bn0 = norm_layer(channels * radix)
self.relu = ReLU(inplace=True)
self.fc1 = Conv2d(channels, inter_channels, 1, groups=self.cardinality)
if self.use_bn:
self.bn1 = norm_layer(inter_channels)
self.fc2 = Conv2d(inter_channels,
channels * radix,
1,
groups=self.cardinality)
if dropblock_prob > 0.0:
self.dropblock = DropBlock2D(dropblock_prob, 3)
self.rsoftmax = rSoftMax(radix, groups)
def __init__(self,
in_channels,
out_channels,
kernel_size,
in_length,
out_length,
stride=1,
padding=0,
dilation=1,
share_weight=True,
routing_type='k_means',
num_iterations=3,
bias=True,
**kwargs):
super(CapsuleConv2d, self).__init__()
if in_channels % in_length != 0:
raise ValueError(
'Expected in_channels must be divisible by in_length.')
if out_channels % out_length != 0:
raise ValueError(
'Expected out_channels must be divisible by out_length.')
if num_iterations < 1:
raise ValueError(
'num_iterations has to be greater than 0, but got {}.'.format(
num_iterations))
kernel_size = _pair(kernel_size)
stride = _pair(stride)
padding = _pair(padding)
dilation = _pair(dilation)
self.in_channels = in_channels
self.out_channels = out_channels
self.kernel_size = kernel_size
self.in_length = in_length
self.out_length = out_length
self.stride = stride
self.padding = padding
self.dilation = dilation
self.share_weight = share_weight
self.routing_type = routing_type
self.num_iterations = num_iterations
self.kwargs = kwargs
if self.share_weight:
self.weight = Parameter(
torch.Tensor(out_channels // out_length, out_length, in_length,
*kernel_size))
else:
self.weight = Parameter(
torch.Tensor(out_channels // out_length,
in_channels // in_length, out_length, in_length,
*kernel_size))
if bias:
self.bias = Parameter(
torch.Tensor(out_channels // out_length, out_length))
nn.init.zeros_(self.bias)
else:
self.bias = None
nn.init.xavier_uniform_(self.weight)
def conv2d(input,
weight,
bias,
stride=1,
padding=0,
dilation=1,
groups=1,
padding_mode='zeros',
scale=1.0,
zero_point=0,
dtype=torch.quint8):
r"""
Applies a 2D convolution over a quantized 2D input composed of several input
planes.
See :class:`~torch.nn.quantized.Conv2d` for details and output shape.
Args:
input: quantized input tensor of shape :math:`(\text{minibatch} , \text{in\_channels} , iH , iW)`
weight: quantized filters of shape :math:`(\text{out\_channels} , \frac{\text{in\_channels}}{\text{groups}} , kH , kW)`
bias: **non-quantized** bias tensor of shape :math:`(\text{out\_channels})`. The tensor type must be `torch.float`.
stride: the stride of the convolving kernel. Can be a single number or a
tuple `(sH, sW)`. Default: 1
padding: implicit paddings on both sides of the input. Can be a
single number or a tuple `(padH, padW)`. Default: 0
dilation: the spacing between kernel elements. Can be a single number or
a tuple `(dH, dW)`. Default: 1
groups: split input into groups, :math:`\text{in\_channels}` should be divisible by the
number of groups. Default: 1
padding_mode: the padding mode to use. Only "zeros" is supported for quantized convolution at the moment. Default: "zeros"
scale: quantization scale for the output. Default: 1.0
zero_point: quantization zero_point for the output. Default: 0
dtype: quantization data type to use. Default: ``torch.quint8``
Examples::
>>> from torch.nn.quantized import functional as qF
>>> filters = torch.randn(8, 4, 3, 3, dtype=torch.float)
>>> inputs = torch.randn(1, 4, 5, 5, dtype=torch.float)
>>> bias = torch.randn(8, dtype=torch.float)
>>>
>>> scale, zero_point = 1.0, 0
>>> dtype_inputs = torch.quint8
>>> dtype_filters = torch.qint8
>>>
>>> q_filters = torch.quantize_per_tensor(filters, scale, zero_point, dtype_filters)
>>> q_inputs = torch.quantize_per_tensor(inputs, scale, zero_point, dtype_inputs)
>>> qF.conv2d(q_inputs, q_filters, bias, padding=1, scale=scale, zero_point=zero_point)
""" # noqa: E501
if padding_mode != 'zeros':
raise NotImplementedError("Only zero-padding is supported!")
if input.dtype != torch.quint8:
raise NotImplementedError(
"Only torch.quint8 is supported for activation tensor!")
if weight.dtype != torch.qint8:
raise NotImplementedError(
"Only torch.qint8 is supported for weight tensor!")
if input.ndim != 4:
raise ValueError("Input shape must be `(N, C, H, W)`!")
stride = _pair(stride)
padding = _pair(padding)
dilation = _pair(dilation)
packed_params = torch.ops.quantized.conv2d_prepack(weight, bias, stride,
padding, dilation,
groups)
return torch.ops.quantized.conv2d(input, packed_params, scale, zero_point)
def __init__(self, output_size, spatial_scale=1.0):
super(RoIPool, self).__init__()
self.output_size = _pair(output_size)
self.spatial_scale = float(spatial_scale)
def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, upsample=1, groups=1, bias=True, activation = 'linear', alpha = 0., residual = None):
super(Conv2d, self).__init__(4, in_channels, out_channels, _pair(kernel_size), _pair(stride), _pair(padding), _pair(dilation), _pair(upsample), groups, bias, activation, alpha, residual)
def forward(ctx, input1, input2, kernel_size, stride, padding,
dilation) -> torch.Tensor:
"""
:param ctx:
:type ctx:
:param input1:
:type input1:
:param input2:
:type input2:
:param kernel_size:
:type kernel_size:
:param stride:
:type stride:
:param padding:
:type padding:
:param dilation:
:type dilation:
:return:
:rtype:
"""
kernel_size, stride, padding, dilation = (
_pair(kernel_size),
_pair(stride),
_pair(padding),
_pair(dilation),
)
ctx.kernel_size, ctx.stride, ctx.padding, ctx.dilation = (
kernel_size,
stride,
padding,
dilation,
)
assert input1.dim() == 4 and input1.is_cuda
batch_size, input_channels, input_height, input_width = input1.size()
output_height = int((input_height + 2 * padding[0] -
(dilation[0] *
(kernel_size[0] - 1) + 1)) / stride[0] + 1)
output_width = int((input_width + 2 * padding[1] -
(dilation[1] *
(kernel_size[1] - 1) + 1)) / stride[1] + 1)
output = input1.new(
batch_size,
input_channels,
kernel_size[0] * kernel_size[1],
output_height * output_width,
)
n = output.numel() // output.shape[2]
with torch.cuda.device_of(input1):
f = load_kernel(
"subtraction2_refpad_forward_kernel",
_subtraction2_refpad_forward_kernel,
Dtype=get_dtype_str(input1),
nthreads=n,
num=batch_size,
input_channels=input_channels,
bottom_height=input_height,
bottom_width=input_width,
top_height=output_height,
top_width=output_width,
kernel_h=kernel_size[0],
kernel_w=kernel_size[1],
stride_h=stride[0],
stride_w=stride[1],
dilation_h=dilation[0],
dilation_w=dilation[1],
pad_h=padding[0],
pad_w=padding[1],
)
f(
block=(CUDA_NUM_THREADS, 1, 1),
grid=(GET_BLOCKS(n), 1, 1),
args=[input1.data_ptr(),
input2.data_ptr(),
output.data_ptr()],
stream=Stream(ptr=torch.cuda.current_stream().cuda_stream),
)
ctx.save_for_backward(input1, input2)
return output
def forward(ctx, input, weight, kernel_size, stride, padding, dilation):
"""
:param ctx:
:type ctx:
:param input:
:type input:
:param weight:
:type weight:
:param kernel_size:
:type kernel_size:
:param stride:
:type stride:
:param padding:
:type padding:
:param dilation:
:type dilation:
:return:
:rtype:"""
kernel_size, stride, padding, dilation = (
_pair(kernel_size),
_pair(stride),
_pair(padding),
_pair(dilation),
)
ctx.kernel_size, ctx.stride, ctx.padding, ctx.dilation = (
kernel_size,
stride,
padding,
dilation,
)
assert input.dim() == 4 and input.is_cuda and weight.is_cuda
batch_size, input_channels, input_height, input_width = input.size()
_, weight_channels, weight_height, weight_width = weight.size()
output_height = int((input_height + 2 * padding[0] -
(dilation[0] *
(kernel_size[0] - 1) + 1)) / stride[0] + 1)
output_width = int((input_width + 2 * padding[1] -
(dilation[1] *
(kernel_size[1] - 1) + 1)) / stride[1] + 1)
assert output_height * output_width == weight_width
output = input.new(batch_size, input_channels, output_height,
output_width)
n = output.numel()
with torch.cuda.device_of(input):
f = load_kernel(
"aggregation_refpad_forward_kernel",
_aggregation_refpad_forward_kernel,
Dtype=get_dtype_str(input),
nthreads=n,
num=batch_size,
input_channels=input_channels,
weight_channels=weight_channels,
bottom_height=input_height,
bottom_width=input_width,
top_height=output_height,
top_width=output_width,
kernel_h=kernel_size[0],
kernel_w=kernel_size[1],
stride_h=stride[0],
stride_w=stride[1],
dilation_h=dilation[0],
dilation_w=dilation[1],
pad_h=padding[0],
pad_w=padding[1],
)
f(
block=(CUDA_NUM_THREADS, 1, 1),
grid=(get_blocks_(n), 1, 1),
args=[input.data_ptr(),
weight.data_ptr(),
output.data_ptr()],
stream=Stream(ptr=torch.cuda.current_stream().cuda_stream),
)
ctx.save_for_backward(input, weight)
return output
def __init__(
self,
source: Nodes,
target: Nodes,
kernel_size: Union[int, Tuple[int, int]],
stride: Union[int, Tuple[int, int]] = 1,
padding: Union[int, Tuple[int, int]] = 0,
dilation: Union[int, Tuple[int, int]] = 1,
nu: Optional[Union[float, Sequence[float]]] = None,
reduction: Optional[callable] = None,
weight_decay: float = 0.0,
**kwargs
) -> None:
# language=rst
"""
Instantiates a ``Conv2dConnection`` object.
:param source: A layer of nodes from which the connection originates.
:param target: A layer of nodes to which the connection connects.
:param kernel_size: Horizontal and vertical size of convolutional kernels.
:param stride: Horizontal and vertical stride for convolution.
:param padding: Horizontal and vertical padding for convolution.
:param dilation: Horizontal and vertical dilation for convolution.
:param nu: Learning rate for both pre- and post-synaptic events.
:param reduction: Method for reducing parameter updates along the minibatch
dimension.
:param weight_decay: Constant multiple to decay weights by on each iteration.
Keyword arguments:
:param LearningRule update_rule: Modifies connection parameters according to
some rule.
:param torch.Tensor w: Strengths of synapses.
:param torch.Tensor b: Target population bias.
:param float wmin: Minimum allowed value on the connection weights.
:param float wmax: Maximum allowed value on the connection weights.
:param float norm: Total weight per target neuron normalization constant.
"""
super().__init__(source, target, nu, reduction, weight_decay, **kwargs)
self.kernel_size = _pair(kernel_size)
self.stride = _pair(stride)
self.padding = _pair(padding)
self.dilation = _pair(dilation)
self.in_channels, input_height, input_width = (
source.shape[0],
source.shape[1],
source.shape[2],
)
self.out_channels, output_height, output_width = (
target.shape[0],
target.shape[1],
target.shape[2],
)
width = (
input_height - self.kernel_size[0] + 2 * self.padding[0]
) / self.stride[0] + 1
height = (
input_width - self.kernel_size[1] + 2 * self.padding[1]
) / self.stride[1] + 1
shape = (self.in_channels, self.out_channels, int(width), int(height))
error = (
"Target dimensionality must be (out_channels, ?,"
"(input_height - filter_height + 2 * padding_height) / stride_height + 1,"
"(input_width - filter_width + 2 * padding_width) / stride_width + 1"
)
assert (
target.shape[0] == shape[1]
and target.shape[1] == shape[2]
and target.shape[2] == shape[3]
), error
w = kwargs.get("w", None)
if w is None:
if self.wmin == -np.inf or self.wmax == np.inf:
w = torch.clamp(
torch.rand(self.out_channels, self.in_channels, *self.kernel_size),
self.wmin,
self.wmax,
)
else:
w = (self.wmax - self.wmin) * torch.rand(
self.out_channels, self.in_channels, *self.kernel_size
)
w += self.wmin
else:
if self.wmin != -np.inf or self.wmax != np.inf:
w = torch.clamp(w, self.wmin, self.wmax)
self.w = Parameter(w, requires_grad=False)
self.b = Parameter(
kwargs.get("b", torch.zeros(self.out_channels)), requires_grad=False
)
def __init__(self,
source: Nodes,
target: Nodes,
kernel_size: Union[int, Tuple[int, int]],
stride: Union[int, Tuple[int, int]] = 1,
padding: Union[int, Tuple[int, int]] = 0,
dilation: Union[int, Tuple[int, int]] = 1,
nu: Optional[Union[float, Tuple[float, float]]] = None,
**kwargs) -> None:
# language=rst
"""
Instantiates a ``Conv2dConnection`` object.
:param source: A layer of nodes from which the connection originates.
:param target: A layer of nodes to which the connection connects.
:param kernel_size: Horizontal and vertical size of convolutional kernels.
:param stride: Horizontal and vertical stride for convolution.
:param padding: Horizontal and vertical padding for convolution.
:param dilation: Horizontal and vertical dilation for convolution.
:param nu: Learning rate for both pre- and post-synaptic events.
:param nu_pre: Learning rate for pre-synaptic events.
:param nu_post: Learning rate for post-synpatic events.
Keyword arguments:
:param function update_rule: Modifies connection parameters according to some rule.
:param torch.Tensor w: Strengths of synapses.
:param float wmin: Minimum allowed value on the connection weights.
:param float wmax: Maximum allowed value on the connection weights.
:param float norm: Total weight per target neuron normalization constant.
"""
super().__init__(source, target, nu, **kwargs)
self.kernel_size = _pair(kernel_size)
self.stride = _pair(stride)
self.padding = _pair(padding)
self.dilation = _pair(dilation)
assert source.shape[0] == target.shape[
0], 'Minibatch size not equal across source and target'
minibatch = source.shape[0]
self.in_channels, input_height, input_width = source.shape[
1], source.shape[2], source.shape[3]
self.out_channels, output_height, output_width = target.shape[
1], target.shape[2], target.shape[3]
error = 'Target dimensionality must be (minibatch, out_channels, \
(input_height - filter_height + 2 * padding_height) / stride_height + 1, \
(input_width - filter_width + 2 * padding_width) / stride_width + 1'
width = (input_height - self.kernel_size[0] +
2 * self.padding[0]) / self.stride[0] + 1
height = (input_width - self.kernel_size[1] +
2 * self.padding[1]) / self.stride[1] + 1
shape = (minibatch, self.out_channels, width, height)
assert tuple(target.shape) == shape, error
self.w = kwargs.get(
'w',
torch.rand(self.out_channels, self.in_channels, *self.kernel_size))
self.w = torch.clamp(self.w, self.wmin, self.wmax)
def __init__(
self,
source: Nodes,
target: Nodes,
kernel_size: Union[int, Tuple[int, int]],
stride: Union[int, Tuple[int, int]],
n_filters: int,
nu: Optional[Union[float, Sequence[float]]] = None,
reduction: Optional[callable] = None,
weight_decay: float = 0.0,
**kwargs
) -> None:
# language=rst
"""
Instantiates a ``LocalConnection`` object. Source population should be
two-dimensional.
Neurons in the post-synaptic population are ordered by receptive field; that is,
if there are ``n_conv`` neurons in each post-synaptic patch, then the first
``n_conv`` neurons in the post-synaptic population correspond to the first
receptive field, the second ``n_conv`` to the second receptive field, and so on.
:param source: A layer of nodes from which the connection originates.
:param target: A layer of nodes to which the connection connects.
:param kernel_size: Horizontal and vertical size of convolutional kernels.
:param stride: Horizontal and vertical stride for convolution.
:param n_filters: Number of locally connected filters per pre-synaptic region.
:param nu: Learning rate for both pre- and post-synaptic events.
:param reduction: Method for reducing parameter updates along the minibatch
dimension.
:param weight_decay: Constant multiple to decay weights by on each iteration.
Keyword arguments:
:param LearningRule update_rule: Modifies connection parameters according to
some rule.
:param torch.Tensor w: Strengths of synapses.
:param torch.Tensor b: Target population bias.
:param float wmin: Minimum allowed value on the connection weights.
:param float wmax: Maximum allowed value on the connection weights.
:param float norm: Total weight per target neuron normalization constant.
:param Tuple[int, int] input_shape: Shape of input population if it's not
``[sqrt, sqrt]``.
"""
super().__init__(source, target, nu, reduction, weight_decay, **kwargs)
kernel_size = _pair(kernel_size)
stride = _pair(stride)
self.kernel_size = kernel_size
self.stride = stride
self.n_filters = n_filters
shape = kwargs.get("input_shape", None)
if shape is None:
sqrt = int(np.sqrt(source.n))
shape = _pair(sqrt)
if kernel_size == shape:
conv_size = [1, 1]
else:
conv_size = (
int((shape[0] - kernel_size[0]) / stride[0]) + 1,
int((shape[1] - kernel_size[1]) / stride[1]) + 1,
)
self.conv_size = conv_size
conv_prod = int(np.prod(conv_size))
kernel_prod = int(np.prod(kernel_size))
assert (
target.n == n_filters * conv_prod
), "Target layer size must be n_filters * (kernel_size ** 2)."
locations = torch.zeros(
kernel_size[0], kernel_size[1], conv_size[0], conv_size[1]
).long()
for c1 in range(conv_size[0]):
for c2 in range(conv_size[1]):
for k1 in range(kernel_size[0]):
for k2 in range(kernel_size[1]):
location = (
c1 * stride[0] * shape[1]
+ c2 * stride[1]
+ k1 * shape[0]
+ k2
)
locations[k1, k2, c1, c2] = location
self.register_buffer("locations", locations.view(kernel_prod, conv_prod))
w = kwargs.get("w", None)
if w is None:
w = torch.zeros(source.n, target.n)
for f in range(n_filters):
for c in range(conv_prod):
for k in range(kernel_prod):
if self.wmin == -np.inf or self.wmax == np.inf:
w[self.locations[k, c], f * conv_prod + c] = np.clip(
np.random.rand(), self.wmin, self.wmax
)
else:
w[
self.locations[k, c], f * conv_prod + c
] = self.wmin + np.random.rand() * (self.wmax - self.wmin)
else:
if self.wmin != -np.inf or self.wmax != np.inf:
w = torch.clamp(w, self.wmin, self.wmax)
self.w = Parameter(w, requires_grad=False)
self.register_buffer("mask", self.w == 0)
self.b = Parameter(kwargs.get("b", torch.zeros(target.n)), requires_grad=False)
if self.norm is not None:
self.norm *= kernel_prod
def __init__(self,
source: Nodes,
target: Nodes,
kernel_size: Union[int, Tuple[int, int]],
stride: Union[int, Tuple[int, int]],
n_filters: int,
nu: Optional[Union[float, Tuple[float, float]]] = None,
weight_decay: float = 0.0,
**kwargs) -> None:
# language=rst
"""
Instantiates a ``LocallyConnectedConnection`` object. Source population should be two-dimensional.
:param source: A layer of nodes from which the connection originates.
:param target: A layer of nodes to which the connection connects.
:param kernel_size: Horizontal and vertical size of convolutional kernels.
:param stride: Horizontal and vertical stride for convolution.
:param n_filters: Number of locally connected filters per pre-synaptic region.
:param nu: Learning rate for both pre- and post-synaptic events.
:param weight_decay: Constant multiple to decay weights by on each iteration.
Keyword arguments:
:param function update_rule: Modifies connection parameters according to some rule.
:param torch.Tensor w: Strengths of synapses.
:param float wmin: Minimum allowed value on the connection weights.
:param float wmax: Maximum allowed value on the connection weights.
:param float norm: Total weight per target neuron normalization constant.
:param Tuple[int, int] input_shape: Shape of input population if it's not ``[sqrt, sqrt]``.
"""
super().__init__(source, target, nu, weight_decay, **kwargs)
kernel_size = _pair(kernel_size)
stride = _pair(stride)
self.kernel_size = kernel_size
self.stride = stride
self.n_filters = n_filters
shape = kwargs.get('input_shape', None)
if shape is None:
sqrt = int(np.sqrt(source.n))
shape = _pair(sqrt)
if kernel_size == shape:
conv_size = [1, 1]
else:
conv_size = (int((shape[0] - kernel_size[0]) / stride[0]) + 1,
int((shape[1] - kernel_size[1]) / stride[1]) + 1)
self.conv_size = conv_size
conv_prod = int(np.prod(conv_size))
kernel_prod = int(np.prod(kernel_size))
assert target.n == n_filters * conv_prod, 'Target layer size must be n_filters * (kernel_size ** 2).'
locations = torch.zeros(kernel_size[0], kernel_size[1], conv_size[0],
conv_size[1]).long()
for c1 in range(conv_size[0]):
for c2 in range(conv_size[1]):
for k1 in range(kernel_size[0]):
for k2 in range(kernel_size[1]):
location = c1 * stride[0] * shape[1] + c2 * stride[
1] + k1 * shape[0] + k2
locations[k1, k2, c1, c2] = location
self.locations = locations.view(kernel_prod, conv_prod)
self.w = kwargs.get('w', None)
if self.w is None:
self.w = torch.zeros(source.n, target.n)
for f in range(n_filters):
for c in range(conv_prod):
for k in range(kernel_prod):
if self.wmin == -np.inf or self.wmax == np.inf:
self.w[self.locations[k, c],
f * conv_prod + c] = np.random.rand()
else:
self.w[self.locations[k, c], f * conv_prod + c] = \
self.wmin + np.random.rand() * (self.wmax - self.wmin)
else:
if self.wmin is not None and self.wmax is not None:
self.w = torch.clamp(self.w, self.wmin, self.wmax)
self.mask = self.w == 0
if self.norm is not None:
self.norm *= kernel_prod
def __init__(self, n_inpt: int, input_shape: List[int], kernel_size: Union[int, Tuple[int, int]],
stride: Union[int, Tuple[int, int]], n_filters: int, inh: float = 25.0, dt: float = 1.0,
nu_pre: float = 1e-4, nu_post: float = 1e-2, theta_plus: float = 0.05, theta_decay: float = 1e-7,
wmin: float = 0.0, wmax: float = 1.0, norm: float = 0.2) -> None:
# language=rst
"""
Constructor for class ``LocallyConnectedNetwork``. Uses ``DiehlAndCookNodes`` to avoid multiple spikes per
timestep in the output layer population.
:param n_inpt: Number of input neurons. Matches the 1D size of the input data.
:param input_shape: Two-dimensional shape of input population.
:param kernel_size: Size of input windows. Integer or two-tuple of integers.
:param stride: Length of horizontal, vertical stride across input space. Integer or two-tuple of integers.
:param n_filters: Number of locally connected filters per input region. Integer or two-tuple of integers.
:param inh: Strength of synapse weights from output layer back onto itself.
:param dt: Simulation time step.
:param nu_pre: Pre-synaptic learning rate.
:param nu_post: Post-synaptic learning rate.
:param wmin: Minimum allowed weight on ``Input`` to ``DiehlAndCookNodes`` synapses.
:param wmax: Maximum allowed weight on ``Input`` to ``DiehlAndCookNodes`` synapses.
:param theta_plus: On-spike increment of ``DiehlAndCookNodes`` membrane threshold potential.
:param theta_decay: Time constant of ``DiehlAndCookNodes`` threshold potential decay.
:param norm: ``Input`` to ``DiehlAndCookNodes`` layer connection weights normalization constant.
"""
super().__init__(dt=dt)
kernel_size = _pair(kernel_size)
stride = _pair(stride)
self.n_inpt = n_inpt
self.input_shape = input_shape
self.kernel_size = kernel_size
self.stride = stride
self.n_filters = n_filters
self.inh = inh
self.dt = dt
self.theta_plus = theta_plus
self.theta_decay = theta_decay
self.wmin = wmin
self.wmax = wmax
self.norm = norm
if kernel_size == input_shape:
conv_size = [1, 1]
else:
conv_size = (int((input_shape[0] - kernel_size[0]) / stride[0]) + 1,
int((input_shape[1] - kernel_size[1]) / stride[1]) + 1)
input_layer = Input(n=self.n_inpt, traces=True, trace_tc=5e-2)
output_layer = DiehlAndCookNodes(
n=self.n_filters * conv_size[0] * conv_size[1], traces=True, rest=-65.0, reset=-60.0,
thresh=-52.0, refrac=5, decay=1e-2, trace_tc=5e-2, theta_plus=theta_plus, theta_decay=theta_decay
)
input_output_conn = LocallyConnectedConnection(
input_layer, output_layer, kernel_size=kernel_size, stride=stride, n_filters=n_filters,
nu=(nu_pre, nu_post), update_rule=PostPre, wmin=wmin, wmax=wmax, norm=norm, input_shape=input_shape
)
w = torch.zeros(n_filters, *conv_size, n_filters, *conv_size)
for fltr1 in range(n_filters):
for fltr2 in range(n_filters):
if fltr1 != fltr2:
for i in range(conv_size[0]):
for j in range(conv_size[1]):
w[fltr1, i, j, fltr2, i, j] = -inh
recurrent_conn = Connection(output_layer, output_layer, w=w)
self.add_layer(input_layer, name='X')
self.add_layer(output_layer, name='Y')
self.add_connection(input_output_conn, source='X', target='Y')
self.add_connection(recurrent_conn, source='Y', target='Y')
def forward(
ctx,
input,
offset,
weight,
stride=1,
padding=0,
dilation=1,
groups=1,
deformable_groups=1,
im2col_step=64,
):
if input is not None and input.dim() != 4:
raise ValueError(
"Expected 4D tensor as input, got {}D tensor instead.".format(
input.dim()))
ctx.stride = _pair(stride)
ctx.padding = _pair(padding)
ctx.dilation = _pair(dilation)
ctx.groups = groups
ctx.deformable_groups = deformable_groups
ctx.im2col_step = im2col_step
ctx.save_for_backward(input, offset, weight)
output = input.new_empty(
_DeformConv._output_size(input, weight, ctx.padding, ctx.dilation,
ctx.stride))
ctx.bufs_ = [input.new_empty(0), input.new_empty(0)] # columns, ones
if not input.is_cuda:
if deformable_groups != 1:
raise NotImplementedError(
"Deformable Conv with deformable_groups != 1 is not supported on CPUs!"
)
return deform_conv2d(input,
offset,
weight,
stride=stride,
padding=padding,
dilation=dilation)
else:
cur_im2col_step = _DeformConv._cal_im2col_step(
input.shape[0], ctx.im2col_step)
assert (input.shape[0] %
cur_im2col_step) == 0, "im2col step must divide batchsize"
_C.deform_conv_forward(
input,
weight,
offset,
output,
ctx.bufs_[0],
ctx.bufs_[1],
weight.size(3),
weight.size(2),
ctx.stride[1],
ctx.stride[0],
ctx.padding[1],
ctx.padding[0],
ctx.dilation[1],
ctx.dilation[0],
ctx.groups,
ctx.deformable_groups,
cur_im2col_step,
)
return output
def __init__(self, kernel_size=2, stride=2, padding=0, same=False):
super(QuaternionMaxAmpPool2d, self).__init__()
self.k = _pair(kernel_size)
self.stride = _pair(stride)
self.padding = _quadruple(padding) # convert to l, r, t, b
self.same = same
def adaptive_avg_pool2d(input, output_size: Vector):
return torch.ops.torch_ipex.adaptive_avg_pool2d(input, _pair(output_size))
def forward(ctx,
input,
offset,
weight,
stride=1,
padding=0,
dilation=1,
groups=1,
deform_groups=1,
bias=False,
im2col_step=32):
if input is not None and input.dim() != 4:
raise ValueError(
f'Expected 4D tensor as input, got {input.dim()}D tensor \
instead.')
assert bias is False, 'Only support bias is False.'
ctx.stride = _pair(stride)
ctx.padding = _pair(padding)
ctx.dilation = _pair(dilation)
ctx.groups = groups
ctx.deform_groups = deform_groups
ctx.im2col_step = im2col_step
# When pytorch version >= 1.6.0, amp is adopted for fp16 mode;
# amp won't cast the type of model (float32), but "offset" is cast
# to float16 by nn.Conv2d automatically, leading to the type
# mismatch with input (when it is float32) or weight.
# The flag for whether to use fp16 or amp is the type of "offset",
# we cast weight and input to temporarily support fp16 and amp
# whatever the pytorch version is.
input = input.type_as(offset)
weight = weight.type_as(input)
ctx.save_for_backward(input, offset, weight)
output = input.new_empty(
DeformConv2dFunction._output_size(ctx, input, weight))
ctx.bufs_ = [input.new_empty(0), input.new_empty(0)] # columns, ones
cur_im2col_step = min(ctx.im2col_step, input.size(0))
assert (input.size(0) % cur_im2col_step
) == 0, 'batch size must be divisible by im2col_step'
ext_module.deform_conv_forward(
input,
weight,
offset,
output,
ctx.bufs_[0],
ctx.bufs_[1],
kW=weight.size(3),
kH=weight.size(2),
dW=ctx.stride[1],
dH=ctx.stride[0],
padW=ctx.padding[1],
padH=ctx.padding[0],
dilationW=ctx.dilation[1],
dilationH=ctx.dilation[0],
group=ctx.groups,
deformable_group=ctx.deform_groups,
im2col_step=cur_im2col_step)
return output
