def _build_weights(self, dim_in, dim_out): self.conv1 = nn.Conv2D(dim_in, dim_in, 3, 1, 1) self.conv2 = nn.Conv2D(dim_in, dim_out, 3, 1, 1) if self.normalize: self.norm1 = fluid.dygraph.InstanceNorm( dim_in, epsilon=1e-05, param_attr=fluid.ParamAttr( initializer=fluid.initializer.Constant(1.0), trainable=False), bias_attr=fluid.ParamAttr( initializer=fluid.initializer.Constant(0.0), trainable=False), dtype='float32') # affine=False,对应代码中的两个参数设置 self.norm2 = fluid.dygraph.InstanceNorm( dim_in, epsilon=1e-05, param_attr=fluid.ParamAttr( initializer=fluid.initializer.Constant(1.0), trainable=False), bias_attr=fluid.ParamAttr( initializer=fluid.initializer.Constant(0.0), trainable=False), dtype='float32') # affine=False,对应代码中的两个参数设置 if self.learned_sc: self.conv1x1 = nn.Conv2D(dim_in, dim_out, 1, 1, 0, bias_attr=False)
def __init__(self, img_size=256, style_dim=64, num_domains=2, max_conv_dim=512): super().__init__() self.num_domains = num_domains dim_in = 2**14 // img_size blocks = [] blocks += [nn.Conv2D(3, dim_in, 3, 1, 1)] repeat_num = int(np.log2(img_size)) - 2 for _ in range(repeat_num): dim_out = min(dim_in * 2, max_conv_dim) blocks += [ResBlk(dim_in, dim_out, downsample=True)] dim_in = dim_out blocks += [LeakyRelu(alpha=0.2)] blocks += [nn.Conv2D(dim_out, dim_out, 4, 1, 0)] blocks += [LeakyRelu(alpha=0.2)] self.shared = fluid.dygraph.Sequential(*blocks) self.unshared = fluid.dygraph.Sequential() for _ in range(num_domains): self.unshared.add_sublayer(f'lsub_{_}', nn.Linear(dim_out, style_dim))
def _build_weights(self, dim_in, dim_out, style_dim=64): self.conv1 = nn.Conv2D(dim_in, dim_out, 3, 1, 1) self.conv2 = nn.Conv2D(dim_out, dim_out, 3, 1, 1) self.norm1 = AdaIN(style_dim, dim_in) self.norm2 = AdaIN(style_dim, dim_out) if self.learned_sc: self.conv1x1 = nn.Conv2D(dim_in, dim_out, 1, 1, 0, bias_attr=False)
def __init__(self): super(ModelConv, self).__init__() with supernet(kernel_size=(3, 5, 7), channel=((4, 8, 12), (8, 12, 16), (8, 12, 16), (8, 12, 16))) as ofa_super: models = [] models += [nn.Conv2D(3, 4, 3, padding=1)] models += [nn.InstanceNorm(4)] models += [ReLU()] models += [nn.Conv2D(4, 4, 3, groups=4)] models += [nn.InstanceNorm(4)] models += [ReLU()] models += [ nn.Conv2DTranspose(4, 4, 3, groups=4, padding=1, use_cudnn=True) ] models += [nn.BatchNorm(4)] models += [ReLU()] models += [nn.Conv2D(4, 3, 3)] models += [ReLU()] models = ofa_super.convert(models) models += [ Block(SuperSeparableConv2D(3, 6, 1, padding=1, candidate_config={'channel': (3, 6)}), fixed=True) ] with supernet(kernel_size=(3, 5, 7), expand_ratio=(1, 2, 4)) as ofa_super: models1 = [] models1 += [nn.Conv2D(6, 4, 3)] models1 += [nn.BatchNorm(4)] models1 += [ReLU()] models1 += [nn.Conv2D(4, 4, 3, groups=2)] models1 += [nn.InstanceNorm(4)] models1 += [ReLU()] models1 += [nn.Conv2DTranspose(4, 4, 3, groups=2)] models1 += [nn.BatchNorm(4)] models1 += [ReLU()] models1 += [nn.Conv2DTranspose(4, 4, 3)] models1 += [nn.BatchNorm(4)] models1 += [ReLU()] models1 = ofa_super.convert(models1) models += models1 self.models = paddle.nn.Sequential(*models)
def __init__(self, in_planes, out_planes, stride=1): super(Block, self).__init__() self.conv1 = nn.Conv2D(in_planes, in_planes, filter_size=3, stride=stride, padding=1, groups=in_planes, bias_attr=False) self.bn1 = nn.InstanceNorm(in_planes) self.conv2 = nn.Conv2D(in_planes, out_planes, filter_size=1, stride=1, padding=0) self.bn2 = nn.InstanceNorm(out_planes)
def __init__(self): super(MobileNet, self).__init__() self.conv1 = nn.Conv2D(shape[0], shape[0], filter_size=3, stride=1, padding=1, bias_attr=False) self.bn1 = nn.InstanceNorm(shape[0]) self._layers = self._make_layers(in_planes=shape[0]) self.conv_last = nn.Conv2D(shape[0], shape[0], filter_size=3, stride=1, padding=1, bias_attr=False)
def __init__(self, in_channels, out_channels, filter_size, stride=1, padding=0, dilation=1, groups=1, bn_init_constant=1.0): super(ConvBNLayer, self).__init__() self.conv = nn.Conv2D(num_channels=in_channels, filter_size=filter_size, num_filters=out_channels, stride=stride, padding=padding, dilation=dilation, groups=groups, param_attr=weight_init(), bias_attr=False) self.bn = nn.BatchNorm(out_channels, param_attr=norm_weight_init(bn_init_constant), bias_attr=norm_bias_init(), act=None, momentum=0.1, use_global_stats=True)
def __init__(self, img_size=256, num_domains=2, max_conv_dim=512): super().__init__() dim_in = 2**14 // img_size blocks = [] blocks += [nn.Conv2D(3, dim_in, 3, 1, 1)] repeat_num = int(np.log2(img_size)) - 2 for _ in range(repeat_num): dim_out = min(dim_in * 2, max_conv_dim) blocks += [ResBlk(dim_in, dim_out, downsample=True)] dim_in = dim_out blocks += [LeakyRelu(alpha=0.2)] blocks += [nn.Conv2D(dim_out, dim_out, 4, 1, 0)] blocks += [LeakyRelu(alpha=0.2)] blocks += [nn.Conv2D(dim_out, num_domains, 1, 1, 0)] self.main = fluid.dygraph.Sequential(*blocks)
def __init__(self): super(Model, self).__init__() with supernet(kernel_size=(3, 5, 7), expand_ratio=[1, 2, 4]) as ofa_super: models = [] models += [nn.Conv2D(1, 6, 3)] models += [ReLU()] models += [nn.Pool2D(2, 'max', 2)] models += [nn.Conv2D(6, 16, 5, padding=0)] models += [ReLU()] models += [nn.Pool2D(2, 'max', 2)] models += [ nn.Linear(784, 120), nn.Linear(120, 84), nn.Linear(84, 10) ] models = ofa_super.convert(models) self.models = paddle.nn.Sequential(*models)
def __init__(self, num_channels, num_filters, is_test=False): super(AdjustLayer, self).__init__() self.conv = nn.Conv2D(num_channels=num_channels, num_filters=num_filters, filter_size=1, param_attr=weight_init(), bias_attr=False) self.bn = nn.BatchNorm(num_channels=num_filters, param_attr=norm_weight_init(), bias_attr=norm_bias_init(), momentum=0.9, act=None, use_global_stats=is_test)
def __init__(self, name_scope, num_classes=1): super(LeNet, self).__init__(name_scope) # 创建卷积和池化层块,每个卷积层使用Sigmoid激活函数,后面跟着一个2x2的池化 self.conv1 = nn.Conv2D(num_channels=1, num_filters=6, filter_size=5, act='sigmoid') self.pool1 = nn.Pool2D(pool_size=2, pool_stride=2, pool_type='max') self.conv2 = nn.Conv2D(num_channels=6, num_filters=16, filter_size=5, act='sigmoid') self.pool2 = nn.Pool2D(pool_size=2, pool_stride=2, pool_type='max') # 创建第3个卷积层 self.conv3 = nn.Conv2D(num_channels=16, num_filters=120, filter_size=4, act='sigmoid') # 创建全连接层,第一个全连接层的输出神经元个数为64, 第二个全连接层输出神经元个数为分裂标签的类别数 self.fc1 = nn.Linear(input_dim=120, output_dim=64, act='sigmoid') self.fc2 = nn.Linear(input_dim=64, output_dim=num_classes)
def __init__(self, name): super().__init__(name) init_w = fluid.ParamAttr( name="a_weight", initializer=fluid.initializer.ConstantInitializer(0.001), learning_rate=0., trainable=False) init_b = fluid.ParamAttr( name="a_bias", initializer=fluid.initializer.ConstantInitializer(0.), trainable=True) self.adjust_conv = nn.Conv2D(1, 1, 1, 1, 0, param_attr=init_w, bias_attr=init_b)
def __init__(self, in_channels, out_channels, filter_size, stride=1, groups=1, padding=1, is_test=False): super(ConvBNReluLayer, self).__init__() self.conv = nn.Conv2D(num_channels=in_channels, filter_size=filter_size, num_filters=out_channels, stride=stride, padding=padding, groups=groups, bias_attr=bias_init(), param_attr=weight_init()) self.bn = nn.BatchNorm(out_channels, param_attr=norm_weight_init(), bias_attr=norm_bias_init(), act=None, momentum=0.9, use_global_stats=is_test)
def __init__(self, num_channels, num_filters, filter_size, stride=1, padding=0, dilation=1): super(Conv1d, self).__init__() self.conv2d = nn.Conv2D(num_channels, num_filters, (filter_size, 1), stride=stride, padding=[padding, 0], dilation=[dilation, 1])
def __init__(self, img_size=256, style_dim=64, max_conv_dim=512, w_hpf=1): super().__init__() dim_in = 2**14 // img_size # dim_in: 64 self.img_size = img_size self.from_rgb = nn.Conv2D(3, dim_in, 3, 1, 1) self.encode = fluid.dygraph.Sequential() self.decode = fluid.dygraph.Sequential() self.to_rgb = fluid.dygraph.Sequential( fluid.dygraph.InstanceNorm( dim_in, epsilon=1e-05, param_attr=fluid.ParamAttr( initializer=fluid.initializer.Constant(1.0), trainable=False), bias_attr=fluid.ParamAttr( initializer=fluid.initializer.Constant(0.0), trainable=False), dtype='float32'), # affine=False,对应代码中的两个参数设置 # functools.partial(fluid.layers.leaky_relu, alpha=0.2), LeakyRelu(alpha=0.2), nn.Conv2D(dim_in, 3, 1, 1, 0)) self.w_hpf = w_hpf # down/up-sampling blocks repeat_num = int(np.log2(img_size)) - 4 # repeat_num: 4 self.repeat_num = repeat_num if w_hpf > 0: repeat_num += 1 for _ in range(repeat_num): dim_out = min(dim_in * 2, max_conv_dim) self.encode.add_sublayer( f'lsample_{_}', ResBlk(dim_in, dim_out, normalize=True, downsample=True)) self.decode.add_sublayer( f'lsample_{_}', AdainResBlk(dim_out, dim_in, style_dim, w_hpf=w_hpf, upsample=True)) dim_in = dim_out # bottleneck blocks for _ in range(2): self.encode.add_sublayer(f'lbnk_{_}', ResBlk(dim_out, dim_out, normalize=True)) self.decode.add_sublayer( f'lbnk_{_}', AdainResBlk(dim_out, dim_out, style_dim, w_hpf=w_hpf)) self.decode1 = fluid.dygraph.Sequential() for _ in list(range(2))[::-1]: layer = self.decode[f'lbnk_{_}'] self.decode1.add_sublayer(f'lbnk_{_}', layer) for _ in list(range(repeat_num))[::-1]: layer = self.decode[f'lsample_{_}'] self.decode1.add_sublayer(f'lsample_{_}', layer) self.decode = self.decode1 # stack-like if w_hpf > 0: self.hpf = HighPass(w_hpf)
def layer_init(self): # for conv1 self.conv1 = nn.Conv2D(num_channels=3, num_filters=96, filter_size=11, stride=2, padding=0, groups=1, param_attr=self.weight_init(), bias_attr=self.bias_init()) self.bn1 = nn.BatchNorm(num_channels=96, is_test=self.is_test, param_attr=self.norm_weight_init(), bias_attr=self.bias_init(), use_global_stats=self.is_test) self.pool1 = nn.Pool2D(pool_size=3, pool_type="max", pool_stride=2, pool_padding=0) # for conv2 self.conv2 = nn.Conv2D(num_channels=96, num_filters=256, filter_size=5, stride=1, padding=0, groups=2, param_attr=self.weight_init(), bias_attr=self.bias_init()) self.bn2 = nn.BatchNorm(num_channels=256, is_test=self.is_test, param_attr=self.norm_weight_init(), bias_attr=self.bias_init(), use_global_stats=self.is_test) self.pool2 = nn.Pool2D(pool_size=3, pool_type="max", pool_stride=2, pool_padding=0) # for conv3 self.conv3 = nn.Conv2D(num_channels=256, num_filters=384, filter_size=3, stride=1, padding=0, groups=1, param_attr=self.weight_init(), bias_attr=self.bias_init()) self.bn3 = nn.BatchNorm(num_channels=384, is_test=self.is_test, param_attr=self.norm_weight_init(), bias_attr=self.bias_init(), use_global_stats=self.is_test) # for conv4 self.conv4 = nn.Conv2D(num_channels=384, num_filters=384, filter_size=3, stride=1, padding=0, groups=2, param_attr=self.weight_init(), bias_attr=self.bias_init()) self.bn4 = nn.BatchNorm(num_channels=384, is_test=self.is_test, param_attr=self.norm_weight_init(), bias_attr=self.bias_init(), use_global_stats=self.is_test) # for conv5 self.conv5 = nn.Conv2D(num_channels=384, num_filters=256, filter_size=3, stride=1, padding=0, groups=2, param_attr=self.weight_init(), bias_attr=self.bias_init())