def __init__(self, num_convs=0, in_channels=2048, out_channels=256): super(MaskFeat, self).__init__() self.num_convs = num_convs self.in_channels = in_channels self.out_channels = out_channels fan_conv = out_channels * 3 * 3 fan_deconv = out_channels * 2 * 2 mask_conv = nn.Sequential() for i in range(self.num_convs): conv_name = 'mask_inter_feat_{}'.format(i + 1) mask_conv.add_sublayer( conv_name, nn.Conv2D(in_channels=in_channels if i == 0 else out_channels, out_channels=out_channels, kernel_size=3, padding=1, weight_attr=paddle.ParamAttr( initializer=KaimingNormal(fan_in=fan_conv)))) mask_conv.add_sublayer(conv_name + 'act', nn.ReLU()) mask_conv.add_sublayer( 'conv5_mask', nn.Conv2DTranspose( in_channels=self.in_channels, out_channels=self.out_channels, kernel_size=2, stride=2, weight_attr=paddle.ParamAttr(initializer=KaimingNormal( fan_in=fan_deconv)))) mask_conv.add_sublayer('conv5_mask' + 'act', nn.ReLU()) self.upsample = mask_conv
def __init__(self, in_channel, mid_channel, out_channel, fuse): super().__init__() self.conv1 = nn.Conv2D( in_channel, mid_channel, kernel_size=1, bias_attr=False, weight_attr=ParamAttr(initializer=KaimingNormal())) self.conv1_bn = nn.BatchNorm2D(mid_channel) self.conv2 = nn.Conv2D( mid_channel, out_channel, kernel_size=3, stride=1, padding=1, bias_attr=False, weight_attr=ParamAttr(initializer=KaimingNormal())) self.conv2_bn = nn.BatchNorm2D(out_channel) if fuse: self.att_conv = nn.Sequential( nn.Conv2D(mid_channel * 2, 2, kernel_size=1), nn.Sigmoid(), ) else: self.att_conv = None
def __init__(self, num_convs=4, in_channels=256, out_channels=256, norm_type=None): super(MaskFeat, self).__init__() self.num_convs = num_convs self.in_channels = in_channels self.out_channels = out_channels self.norm_type = norm_type fan_conv = out_channels * 3 * 3 fan_deconv = out_channels * 2 * 2 mask_conv = nn.Sequential() if norm_type == 'gn': for i in range(self.num_convs): conv_name = 'mask_inter_feat_{}'.format(i + 1) mask_conv.add_sublayer( conv_name, ConvNormLayer( ch_in=in_channels if i == 0 else out_channels, ch_out=out_channels, filter_size=3, stride=1, norm_type=self.norm_type, norm_name=conv_name + '_norm', initializer=KaimingNormal(fan_in=fan_conv), name=conv_name)) mask_conv.add_sublayer(conv_name + 'act', nn.ReLU()) else: for i in range(self.num_convs): conv_name = 'mask_inter_feat_{}'.format(i + 1) mask_conv.add_sublayer( conv_name, nn.Conv2D( in_channels=in_channels if i == 0 else out_channels, out_channels=out_channels, kernel_size=3, padding=1, weight_attr=paddle.ParamAttr(initializer=KaimingNormal( fan_in=fan_conv)))) mask_conv.add_sublayer(conv_name + 'act', nn.ReLU()) mask_conv.add_sublayer( 'conv5_mask', nn.Conv2DTranspose( in_channels=self.in_channels, out_channels=self.out_channels, kernel_size=2, stride=2, weight_attr=paddle.ParamAttr(initializer=KaimingNormal( fan_in=fan_deconv)))) mask_conv.add_sublayer('conv5_mask' + 'act', nn.ReLU()) self.upsample = mask_conv
def __init__(self, in_channels, out_channels, kernel_size, stride, padding, num_groups=1, act='relu', conv_lr=0.1, conv_decay=0., norm_decay=0., norm_type='bn', name=None): super(ConvBNLayer, self).__init__() self.act = act self._conv = nn.Conv2D( in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding, groups=num_groups, weight_attr=ParamAttr( learning_rate=conv_lr, initializer=KaimingNormal()), bias_attr=False) if norm_type == 'sync_bn': self._batch_norm = nn.SyncBatchNorm(out_channels) else: self._batch_norm = nn.BatchNorm( out_channels, act=None, use_global_stats=False)
def __init__(self, head, roi_extractor=RoIAlign().__dict__, mask_assigner='MaskAssigner', num_classes=80, share_bbox_feat=False): super(MaskHead, self).__init__() self.num_classes = num_classes self.roi_extractor = roi_extractor if isinstance(roi_extractor, dict): self.roi_extractor = RoIAlign(**roi_extractor) self.head = head self.in_channels = head.out_channels() self.mask_assigner = mask_assigner self.share_bbox_feat = share_bbox_feat self.bbox_head = None self.mask_fcn_logits = nn.Conv2D( in_channels=self.in_channels, out_channels=self.num_classes, kernel_size=1, weight_attr=paddle.ParamAttr(initializer=KaimingNormal( fan_in=self.num_classes))) self.mask_fcn_logits.skip_quant = True
def __init__(self, in_channels, out_channels, kernel_size, stride, padding, num_groups=1, act='relu', conv_lr=1., conv_decay=0., norm_decay=0., norm_type='bn', name=None): super(ConvBNLayer, self).__init__() self.act = act self._conv = nn.Conv2D(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding, groups=num_groups, weight_attr=ParamAttr( learning_rate=conv_lr, initializer=KaimingNormal(), regularizer=L2Decay(conv_decay)), bias_attr=False) param_attr = ParamAttr(regularizer=L2Decay(norm_decay)) bias_attr = ParamAttr(regularizer=L2Decay(norm_decay)) if norm_type in ['sync_bn', 'bn']: self._batch_norm = nn.BatchNorm2D(out_channels, weight_attr=param_attr, bias_attr=bias_attr)
def __init__(self, num_channels, filter_size, num_filters, stride, padding, channels=None, num_groups=1, act='hard_swish'): super(ConvBNLayer, self).__init__() self._conv = Conv2D(in_channels=num_channels, out_channels=num_filters, kernel_size=filter_size, stride=stride, padding=padding, groups=num_groups, weight_attr=ParamAttr(initializer=KaimingNormal()), bias_attr=False) self._batch_norm = BatchNorm( num_filters, act=act, param_attr=ParamAttr(regularizer=L2Decay(0.0)), bias_attr=ParamAttr(regularizer=L2Decay(0.0)))
def __init__( self, in_channels, out_channels, kernel_size, stride, padding, groups=1, act=None, name=None, ): super(ConvBNLayer, self).__init__() self._conv = Conv2D(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride, padding=padding, groups=groups, weight_attr=ParamAttr(initializer=KaimingNormal(), name=name + "_weights"), bias_attr=False) self._batch_norm = BatchNorm( out_channels, param_attr=ParamAttr(name=name + "_bn_scale"), bias_attr=ParamAttr(name=name + "_bn_offset"), act=act, moving_mean_name=name + "_bn_mean", moving_variance_name=name + "_bn_variance")
def __init__(self, in_channels, out_channels, kernel_size, stride, padding, groups=1, act=None): super(ConvBNLayer, self).__init__() self._conv = Conv2D(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride, padding=padding, groups=groups, weight_attr=ParamAttr(initializer=KaimingNormal()), bias_attr=False) self._batch_norm = BatchNorm2D( out_channels, weight_attr=ParamAttr(regularizer=L2Decay(0.0)), bias_attr=ParamAttr(regularizer=L2Decay(0.0))) if act == "hard_swish": act = 'hardswish' self.act = act
def __init__(self, in_channels, out_channels, kernel_size, stride=1, groups=1, act="relu", name=None): super(ConvBNLayer, self).__init__() self._conv = Conv2D(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride, padding=(kernel_size - 1) // 2, groups=groups, weight_attr=ParamAttr(initializer=KaimingNormal(), name=name + "_weights"), bias_attr=False) bn_name = name + "_bn" self._batch_norm = BatchNorm( num_channels=out_channels, act=act, param_attr=ParamAttr(name=bn_name + "_scale", regularizer=L2Decay(0.0)), bias_attr=ParamAttr(name=bn_name + "_offset", regularizer=L2Decay(0.0)), moving_mean_name=bn_name + "_mean", moving_variance_name=bn_name + "_variance")
def __init__(self, mask_roi_extractor=None, num_convs=0, feat_in=2048, feat_out=256, mask_num_stages=1, share_bbox_feat=False): super(MaskFeat, self).__init__() self.num_convs = num_convs self.feat_in = feat_in self.feat_out = feat_out self.mask_roi_extractor = mask_roi_extractor self.mask_num_stages = mask_num_stages self.share_bbox_feat = share_bbox_feat self.upsample_module = [] fan_conv = feat_out * 3 * 3 fan_deconv = feat_out * 2 * 2 for i in range(self.mask_num_stages): name = 'stage_{}'.format(i) mask_conv = Sequential() for j in range(self.num_convs): conv_name = 'mask_inter_feat_{}'.format(j + 1) mask_conv.add_sublayer( conv_name, Conv2D(in_channels=feat_in if j == 0 else feat_out, out_channels=feat_out, kernel_size=3, padding=1, weight_attr=ParamAttr(initializer=KaimingNormal( fan_in=fan_conv)), bias_attr=ParamAttr(learning_rate=2., regularizer=L2Decay(0.)))) mask_conv.add_sublayer(conv_name + 'act', ReLU()) mask_conv.add_sublayer( 'conv5_mask', Conv2DTranspose( in_channels=self.feat_in, out_channels=self.feat_out, kernel_size=2, stride=2, weight_attr=ParamAttr(initializer=KaimingNormal( fan_in=fan_deconv)), bias_attr=ParamAttr(learning_rate=2., regularizer=L2Decay(0.)))) mask_conv.add_sublayer('conv5_mask' + 'act', ReLU()) upsample = self.add_sublayer(name, mask_conv) self.upsample_module.append(upsample)
def __init__(self, stages_pattern, scale=1.0, class_num=1000, return_patterns=None, return_stages=None): super().__init__() self.scale = scale self.conv = ConvBNLayer( num_channels=3, filter_size=3, num_filters=int(32 * scale), stride=2, padding=1) #num_channels, num_filters1, num_filters2, num_groups, stride self.cfg = [[int(32 * scale), 32, 64, 32, 1], [int(64 * scale), 64, 128, 64, 2], [int(128 * scale), 128, 128, 128, 1], [int(128 * scale), 128, 256, 128, 2], [int(256 * scale), 256, 256, 256, 1], [int(256 * scale), 256, 512, 256, 2], [int(512 * scale), 512, 512, 512, 1], [int(512 * scale), 512, 512, 512, 1], [int(512 * scale), 512, 512, 512, 1], [int(512 * scale), 512, 512, 512, 1], [int(512 * scale), 512, 512, 512, 1], [int(512 * scale), 512, 1024, 512, 2], [int(1024 * scale), 1024, 1024, 1024, 1]] self.blocks = nn.Sequential(* [ DepthwiseSeparable( num_channels=params[0], num_filters1=params[1], num_filters2=params[2], num_groups=params[3], stride=params[4], scale=scale) for params in self.cfg ]) self.avg_pool = AdaptiveAvgPool2D(1) self.flatten = Flatten(start_axis=1, stop_axis=-1) self.fc = Linear( int(1024 * scale), class_num, weight_attr=ParamAttr(initializer=KaimingNormal())) super().init_res( stages_pattern, return_patterns=return_patterns, return_stages=return_stages)
def __init__(self, in_channels, channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, radix=2, reduction_factor=4, rectify_avg=False, name=None): super(SplatConv, self).__init__() self.radix = radix self.conv1 = ConvBNLayer(num_channels=in_channels, num_filters=channels * radix, filter_size=kernel_size, stride=stride, groups=groups * radix, act="relu", name=name + "_1_weights") self.avg_pool2d = AdaptiveAvgPool2D(1) inter_channels = int(max(in_channels * radix // reduction_factor, 32)) # to calc gap self.conv2 = ConvBNLayer(num_channels=channels, num_filters=inter_channels, filter_size=1, stride=1, groups=groups, act="relu", name=name + "_2_weights") # to calc atten self.conv3 = Conv2D(in_channels=inter_channels, out_channels=channels * radix, kernel_size=1, stride=1, padding=0, groups=groups, weight_attr=ParamAttr(name=name + "_weights", initializer=KaimingNormal()), bias_attr=False) self.rsoftmax = rSoftmax(radix=radix, cardinality=groups)
def __init__(self, in_channels, out_channels, kernel_size, stride, padding=0, p=0.5): super(ConvBlock, self).__init__() self.conv = nn.Conv1D(in_channels, out_channels, kernel_size, stride, padding, weight_attr=KaimingNormal()) self.conv = nn.utils.weight_norm(self.conv) self.act = GLU(axis=1) self.dropout = nn.Dropout(p)
def __init__(self, in_channels, out_channels, kernel_size, stride, padding, num_groups=1, act='relu', conv_lr=1., conv_decay=0., norm_decay=0., norm_type='bn', name=None): super(ConvBNLayer, self).__init__() self.act = act self._conv = nn.Conv2D( in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding, groups=num_groups, weight_attr=ParamAttr( learning_rate=conv_lr, initializer=KaimingNormal(), regularizer=L2Decay(conv_decay), name=name + "_weights"), bias_attr=False) param_attr = ParamAttr( name=name + "_bn_scale", regularizer=L2Decay(norm_decay)) bias_attr = ParamAttr( name=name + "_bn_offset", regularizer=L2Decay(norm_decay)) if norm_type == 'sync_bn': self._batch_norm = nn.SyncBatchNorm( out_channels, weight_attr=param_attr, bias_attr=bias_attr) else: self._batch_norm = nn.BatchNorm( out_channels, act=None, param_attr=param_attr, bias_attr=bias_attr, use_global_stats=False, moving_mean_name=name + '_bn_mean', moving_variance_name=name + '_bn_variance')
def __init__(self, in_dim=256, num_convs=4, conv_dim=256, mlp_dim=1024, resolution=7, norm_type='gn', freeze_norm=False, stage_name=''): super(XConvNormHead, self).__init__() self.in_dim = in_dim self.num_convs = num_convs self.conv_dim = conv_dim self.mlp_dim = mlp_dim self.norm_type = norm_type self.freeze_norm = freeze_norm self.bbox_head_convs = [] fan = conv_dim * 3 * 3 initializer = KaimingNormal(fan_in=fan) for i in range(self.num_convs): in_c = in_dim if i == 0 else conv_dim head_conv_name = stage_name + 'bbox_head_conv{}'.format(i) head_conv = self.add_sublayer( head_conv_name, ConvNormLayer(ch_in=in_c, ch_out=conv_dim, filter_size=3, stride=1, norm_type=self.norm_type, norm_name=head_conv_name + '_norm', freeze_norm=self.freeze_norm, initializer=initializer, name=head_conv_name)) self.bbox_head_convs.append(head_conv) fan = conv_dim * resolution * resolution self.fc6 = nn.Linear(conv_dim * resolution * resolution, mlp_dim, weight_attr=paddle.ParamAttr( initializer=XavierUniform(fan_out=fan)), bias_attr=paddle.ParamAttr( learning_rate=2., regularizer=L2Decay(0.)))
def __init__(self, num_channels, filter_size, num_filters, stride, padding, num_groups=1): super().__init__() self.conv = Conv2D(in_channels=num_channels, out_channels=num_filters, kernel_size=filter_size, stride=stride, padding=padding, groups=num_groups, weight_attr=ParamAttr(initializer=KaimingNormal()), bias_attr=False) self.bn = BatchNorm(num_filters) self.relu = ReLU()
def __init__(self, num_channels, filter_size, num_filters, stride, num_groups=1): super().__init__() self.conv = Conv2D(in_channels=num_channels, out_channels=num_filters, kernel_size=filter_size, stride=stride, padding=(filter_size - 1) // 2, groups=num_groups, weight_attr=ParamAttr(initializer=KaimingNormal()), bias_attr=False) self.bn = BatchNorm(num_filters, param_attr=ParamAttr(regularizer=L2Decay(0.0)), bias_attr=ParamAttr(regularizer=L2Decay(0.0))) self.hardswish = nn.Hardswish()
def __init__(self, in_channels, out_channels, kernel_size, stride=1, groups=1, if_act=True): super().__init__() self.conv = Conv2D(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride, padding=(kernel_size - 1) // 2, groups=groups, weight_attr=ParamAttr(initializer=KaimingNormal()), bias_attr=False) self.bn = BatchNorm(out_channels, param_attr=ParamAttr(regularizer=L2Decay(0.0)), bias_attr=ParamAttr(regularizer=L2Decay(0.0))) self.if_act = if_act self.hardswish = nn.Hardswish()
def __init__(self, mask_feat, feat_in=256, num_classes=81, mask_num_stages=1): super(MaskHead, self).__init__() self.mask_feat = mask_feat self.feat_in = feat_in self.num_classes = num_classes self.mask_num_stages = mask_num_stages self.mask_fcn_logits = [] for i in range(self.mask_num_stages): name = 'mask_fcn_logits_{}'.format(i) self.mask_fcn_logits.append( self.add_sublayer( name, Conv2D(in_channels=self.feat_in, out_channels=self.num_classes, kernel_size=1, weight_attr=ParamAttr(initializer=KaimingNormal( fan_in=self.num_classes)), bias_attr=ParamAttr(learning_rate=2., regularizer=L2Decay(0.0)))))
def get_conv_init(fan_out): return KaimingNormal(fan_in=fan_out)
def __init__(self, scale=1.0, class_dim=1000): super(MobileNet, self).__init__() self.scale = scale self.block_list = [] self.conv1 = ConvBNLayer(num_channels=3, filter_size=3, channels=3, num_filters=int(32 * scale), stride=2, padding=1, name="conv1") conv2_1 = self.add_sublayer("conv2_1", sublayer=DepthwiseSeparable( num_channels=int(32 * scale), num_filters1=32, num_filters2=64, num_groups=32, stride=1, scale=scale, name="conv2_1")) self.block_list.append(conv2_1) conv2_2 = self.add_sublayer("conv2_2", sublayer=DepthwiseSeparable( num_channels=int(64 * scale), num_filters1=64, num_filters2=128, num_groups=64, stride=2, scale=scale, name="conv2_2")) self.block_list.append(conv2_2) conv3_1 = self.add_sublayer("conv3_1", sublayer=DepthwiseSeparable( num_channels=int(128 * scale), num_filters1=128, num_filters2=128, num_groups=128, stride=1, scale=scale, name="conv3_1")) self.block_list.append(conv3_1) conv3_2 = self.add_sublayer("conv3_2", sublayer=DepthwiseSeparable( num_channels=int(128 * scale), num_filters1=128, num_filters2=256, num_groups=128, stride=2, scale=scale, name="conv3_2")) self.block_list.append(conv3_2) conv4_1 = self.add_sublayer("conv4_1", sublayer=DepthwiseSeparable( num_channels=int(256 * scale), num_filters1=256, num_filters2=256, num_groups=256, stride=1, scale=scale, name="conv4_1")) self.block_list.append(conv4_1) conv4_2 = self.add_sublayer("conv4_2", sublayer=DepthwiseSeparable( num_channels=int(256 * scale), num_filters1=256, num_filters2=512, num_groups=256, stride=2, scale=scale, name="conv4_2")) self.block_list.append(conv4_2) for i in range(5): conv5 = self.add_sublayer("conv5_" + str(i + 1), sublayer=DepthwiseSeparable( num_channels=int(512 * scale), num_filters1=512, num_filters2=512, num_groups=512, stride=1, scale=scale, name="conv5_" + str(i + 1))) self.block_list.append(conv5) conv5_6 = self.add_sublayer("conv5_6", sublayer=DepthwiseSeparable( num_channels=int(512 * scale), num_filters1=512, num_filters2=1024, num_groups=512, stride=2, scale=scale, name="conv5_6")) self.block_list.append(conv5_6) conv6 = self.add_sublayer("conv6", sublayer=DepthwiseSeparable( num_channels=int(1024 * scale), num_filters1=1024, num_filters2=1024, num_groups=1024, stride=1, scale=scale, name="conv6")) self.block_list.append(conv6) self.pool2d_avg = AdaptiveAvgPool2D(1) self.out = Linear(int(1024 * scale), class_dim, weight_attr=ParamAttr(initializer=KaimingNormal(), name="fc7_weights"), bias_attr=ParamAttr(name="fc7_offset"))
import numpy as np import paddle import paddle.nn as nn from paddle.nn.initializer import TruncatedNormal, KaimingNormal, Constant, Assign # Common initializations ones_ = Constant(value=1.0) zeros_ = Constant(value=0.0) kaiming_normal_ = KaimingNormal() trunc_normal_ = TruncatedNormal(std=0.02) def orthogonal_(tensor, gain=1): r"""Fills the input `Tensor` with a (semi) orthogonal matrix, as described in `Exact solutions to the nonlinear dynamics of learning in deep linear neural networks` - Saxe, A. et al. (2013). The input tensor must have at least 2 dimensions, and for tensors with more than 2 dimensions the trailing dimensions are flattened. Args: tensor: an n-dimensional `torch.Tensor`, where :math:`n \geq 2` gain: optional scaling factor Examples: >>> w = torch.empty(3, 5) >>> nn.init.orthogonal_(w) """ if tensor.ndimension() < 2: raise ValueError("Only tensors with 2 or more dimensions are supported")
def __init__(self, inplanes, planes, stride=1, radix=1, cardinality=1, bottleneck_width=64, avd=False, avd_first=False, dilation=1, is_first=False, rectify_avg=False, last_gamma=False, avg_down=False, name=None): super(BottleneckBlock, self).__init__() self.inplanes = inplanes self.planes = planes self.stride = stride self.radix = radix self.cardinality = cardinality self.avd = avd self.avd_first = avd_first self.dilation = dilation self.is_first = is_first self.rectify_avg = rectify_avg self.last_gamma = last_gamma self.avg_down = avg_down group_width = int(planes * (bottleneck_width / 64.)) * cardinality self.conv1 = ConvBNLayer(num_channels=self.inplanes, num_filters=group_width, filter_size=1, stride=1, groups=1, act="relu", name=name + "_conv1") if avd and avd_first and (stride > 1 or is_first): self.avg_pool2d_1 = AvgPool2D(kernel_size=3, stride=stride, padding=1) if radix >= 1: self.conv2 = SplatConv(in_channels=group_width, channels=group_width, kernel_size=3, stride=1, padding=dilation, dilation=dilation, groups=cardinality, bias=False, radix=radix, rectify_avg=rectify_avg, name=name + "_splat") else: self.conv2 = ConvBNLayer(num_channels=group_width, num_filters=group_width, filter_size=3, stride=1, dilation=dilation, groups=cardinality, act="relu", name=name + "_conv2") if avd and avd_first == False and (stride > 1 or is_first): self.avg_pool2d_2 = AvgPool2D(kernel_size=3, stride=stride, padding=1) self.conv3 = ConvBNLayer(num_channels=group_width, num_filters=planes * 4, filter_size=1, stride=1, groups=1, act=None, name=name + "_conv3") if stride != 1 or self.inplanes != self.planes * 4: if avg_down: if dilation == 1: self.avg_pool2d_3 = AvgPool2D(kernel_size=stride, stride=stride, padding=0) else: self.avg_pool2d_3 = AvgPool2D(kernel_size=1, stride=1, padding=0, ceil_mode=True) self.conv4 = Conv2D(in_channels=self.inplanes, out_channels=planes * 4, kernel_size=1, stride=1, padding=0, groups=1, weight_attr=ParamAttr( name=name + "_weights", initializer=KaimingNormal()), bias_attr=False) else: self.conv4 = Conv2D(in_channels=self.inplanes, out_channels=planes * 4, kernel_size=1, stride=stride, padding=0, groups=1, weight_attr=ParamAttr( name=name + "_shortcut_weights", initializer=KaimingNormal()), bias_attr=False) bn_decay = 0.0 self._batch_norm = BatchNorm( planes * 4, act=None, param_attr=ParamAttr(name=name + "_shortcut_scale", regularizer=L2Decay(bn_decay)), bias_attr=ParamAttr(name + "_shortcut_offset", regularizer=L2Decay(bn_decay)), moving_mean_name=name + "_shortcut_mean", moving_variance_name=name + "_shortcut_variance")