def __init__(self, num_classes=10): super(MNISTMSNConvNet, self).__init__() self.main = nn.Sequential( SNConv2d(1, 16, kernel_size=5, stride=1, padding=2), MeanSpectralNorm(16), nn.LeakyReLU(0.1, inplace=True), SNConv2d(16, 32, kernel_size=3, stride=1, padding=2), MeanSpectralNorm(32), nn.LeakyReLU(0.1, inplace=True), SNConv2d(32, 32, kernel_size=4, stride=2, padding=2), MeanSpectralNorm(32), nn.LeakyReLU(0.1, inplace=True)) #nn.MaxPool2d(kernel_size=2, stride=2)) self.fc = SNLinear(16 * 16 * 32, num_classes)
def __init__(self, nc, ndf): super(_MSNnetD, self).__init__() self.main = nn.Sequential( # input is (nc) x 32 x 32 #SNConv2d() SNConv2d(nc, ndf, 3, 1, 1, bias=True), nn.LeakyReLU(0.1, inplace=True), SNConv2d(ndf, ndf, 4, 2, 1, bias=True), nn.LeakyReLU(0.1, inplace=True), # state size. (ndf) x 1 x 32 SNConv2d(ndf, ndf * 2, 3, 1, 1, bias=True), nn.LeakyReLU(0.1, inplace=True), SNConv2d(ndf * 2, ndf * 2, 4, 2, 1, bias=True), MeanSpectralNorm(ndf * 2), nn.LeakyReLU(0.1, inplace=True), # state size. (ndf*2) x 16 x 16 SNConv2d(ndf * 2, ndf * 4, 3, 1, 1, bias=True), nn.LeakyReLU(0.1, inplace=True), SNConv2d(ndf * 4, ndf * 4, 4, 2, 1, bias=True), MeanSpectralNorm(ndf * 4), nn.LeakyReLU(0.1, inplace=True), # state size. (ndf*4) x 8 x 8 SNConv2d(ndf * 4, ndf * 8, 3, 1, 1, bias=True), MeanSpectralNorm(ndf * 8), nn.LeakyReLU(0.1, inplace=True), # state size. (ndf*8) x 4 x 4 #SNConv2d(ndf * 8, 1, 4, 1, 0, bias=False), #nn.Sigmoid() ) self.snlinear = SNLinear(ndf * 8 * 4 * 4, 1)
def __init__(self, num_input_features, growth_rate, bn_size, drop_rate): super(_SNDenseLayer, self).__init__() self.add_module("relu1", nn.ReLU(inplace=True)), self.add_module( "conv1", SNConv2d(num_input_features, bn_size * growth_rate, kernel_size=1, stride=1, bias=False)), self.add_module("relu2", nn.ReLU(inplace=True)), self.add_module( "conv2", SNConv2d(bn_size * growth_rate, growth_rate, kernel_size=3, stride=1, padding=1, bias=False)), self.drop_rate = drop_rate
def __init__(self, num_input_features, num_output_features): super(_SNTransition, self).__init__() self.add_module("relu", nn.ReLU(inplace=True)) self.add_module( "conv", SNConv2d(num_input_features, num_output_features, kernel_size=1, stride=1, bias=False)) self.add_module("pool", nn.AvgPool2d(kernel_size=2, stride=2))
def make_layers(cfg, norm='BN'): layers = [] in_channels = 3 for i, v in enumerate(cfg): if v == 'M': layers += [nn.MaxPool2d(kernel_size=2, stride=2)] else: padding = v[1] if isinstance(v, tuple) else 1 out_channels = v[0] if isinstance(v, tuple) else v conv2d = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=padding) if norm == 'BN': layers += [ conv2d, nn.BatchNorm2d(out_channels), nn.ReLU(), nn.Dropout(0.3) ] elif norm == 'SN': SNconv2d = SNConv2d(in_channels, out_channels, kernel_size=3, padding=padding) layers += [SNconv2d, nn.LeakyReLU(0.1, inplace=True)] elif norm == 'MSN': SNconv2d = SNConv2d(in_channels, out_channels, kernel_size=3, padding=padding) layers += [ SNconv2d, MeanSpectralNorm(out_channels), nn.LeakyReLU(0.1, inplace=True) ] else: layers += [conv2d, nn.ReLU(), nn.Dropout(0.3)] in_channels = out_channels return nn.Sequential(*layers)
def __init__( self, growth_rate=12, block_config=(16, 16, 16), compression=0.8, num_init_features=24, bn_size=4, drop_rate=0, avgpool_size=8, num_classes=10, ): super(MSNDenseNet, self).__init__() assert 0 < compression <= 1, "compression of densenet should be between 0 and 1" self.avgpool_size = avgpool_size # First convolution self.features = nn.Sequential( OrderedDict([("conv0", SNConv2d(3, num_init_features, kernel_size=3, stride=1, padding=1, bias=False))])) # Each denseblock num_features = num_init_features for i, num_layers in enumerate(block_config): block = _DenseBlock( num_layers=num_layers, num_input_features=num_features, bn_size=bn_size, growth_rate=growth_rate, drop_rate=drop_rate, ) self.features.add_module("denseblock%d" % (i + 1), block) num_features = num_features + num_layers * growth_rate if i != len(block_config) - 1: trans = _MSNTransition(num_input_features=num_features, num_output_features=int(num_features * compression)) self.features.add_module("transition%d" % (i + 1), trans) num_features = int(num_features * compression) # Final batch norm self.features.add_module("norm_final", MeanSpectralNorm(num_features)) # Linear layer self.classifier = nn.Linear(num_features, num_classes)
def __init__(self, nc, ndf, data_size, num_classes, num_hidden_layers=8, spectral_norm=True): super(ConvNet, self).__init__() model_dict = [{ 'mult': 1, 'kernel': 3, 'stride': 1, 'padding': 1 }, { 'mult': 1, 'kernel': 4, 'stride': 2, 'padding': 1 }, { 'mult': 2, 'kernel': 3, 'stride': 1, 'padding': 1 }, { 'mult': 2, 'kernel': 3, 'stride': 1, 'padding': 1 }, { 'mult': 2, 'kernel': 4, 'stride': 2, 'padding': 1 }, { 'mult': 4, 'kernel': 3, 'stride': 1, 'padding': 1 }, { 'mult': 4, 'kernel': 4, 'stride': 2, 'padding': 1 }, { 'mult': 8, 'kernel': 3, 'stride': 1, 'padding': 1 }] modules = [] out_size = 0 for i in range(num_hidden_layers): if i == 0: in_size = nc H = data_size else: in_size = ndf * model_dict[i - 1]['mult'] out_size = ndf * model_dict[i]['mult'] if spectral_norm == True: modules.append( SNConv2d(in_size, out_size, model_dict[i]['kernel'], model_dict[i]['stride'], model_dict[i]['padding'], bias=True)) else: modules.append( nn.Conv2d(in_size, out_size, model_dict[i]['kernel'], model_dict[i]['stride'], model_dict[i]['padding'], bias=True)) modules.append(nn.LeakyReLU(0.1, inplace=True)) H = floor((H + 2 * (model_dict[i]['padding']) - (model_dict[i]['kernel'] - 1) - 1) / model_dict[i]['stride'] + 1) self.main = nn.Sequential(*modules) self.snlinear = SNLinear(out_size * H * H, num_classes)