def decoder(nz, outSize, channel=3, nf=128): init_dim = 8 layers = int(np.log2(outSize) - 3) decoder_seq = nn.HybridSequential(prefix='decoder') decoder_seq.add( nn.Dense(nf * init_dim ** 2, in_units=nz), nn.HybridLambda(lambda F, x: F.reshape(x, shape=(-1, nf, init_dim, init_dim))), nn.Conv2D(nf, kernel_size=3, strides=3, padding=init_dim), nn.ELU(), nn.Conv2D(nf, kernel_size=3, strides=3, padding=init_dim), nn.ELU(), ) current_dim = init_dim for i in range(layers): current_dim *= 2 decoder_seq.add( nn.HybridLambda(lambda F, x: F.UpSampling(x, scale=2, sample_type='nearest')), nn.Conv2D(nf, kernel_size=3, strides=3, padding=current_dim), nn.ELU(), nn.Conv2D(nf, kernel_size=3, strides=3, padding=current_dim), nn.ELU(), ) decoder_seq.add( nn.Conv2D(channel, kernel_size=3, strides=3, padding=current_dim), nn.ELU(), ) return decoder_seq
def test_lambda(): net1 = mx.gluon.nn.HybridSequential() net1.add(nn.Activation('tanh'), nn.LeakyReLU(0.1)) net2 = mx.gluon.nn.HybridSequential() op3 = lambda F, x, *args: F.LeakyReLU(x, *args, slope=0.1) net2.add(nn.HybridLambda('tanh'), nn.HybridLambda(op3)) op4 = lambda x: mx.nd.LeakyReLU(x, slope=0.1) net3 = mx.gluon.nn.Sequential() net3.add(nn.Lambda('tanh'), nn.Lambda(op4)) input_data = mx.nd.random.uniform(shape=(2, 3, 5, 7)) out1, out2, out3 = net1(input_data), net2(input_data), net3(input_data) assert_almost_equal(out1.asnumpy(), out2.asnumpy(), rtol=1e-3, atol=1e-3) assert_almost_equal(out1.asnumpy(), out3.asnumpy(), rtol=1e-3, atol=1e-3)
def encoder(nz, inSize, channel=3, nf=128): init_dim = 8 layers = int(np.log2(inSize) - 2) encoder_seq = nn.HybridSequential(prefix='encoder') encoder_seq.add( nn.Conv2D(channel, kernel_size=3, strides=3, padding=inSize), nn.ELU(), ) current_dim = inSize for i in range(1, layers): encoder_seq.add( nn.Conv2D(i * nf, kernel_size=3, strides=3, padding=current_dim), nn.ELU(), # nn.Conv2D(i * nf, kernel_size=3, strides=3, padding=current_dim), # nn.ELU(), nn.Conv2D(i * nf, kernel_size=3, strides=2, padding=1), nn.ELU(), ) current_dim //= 2 encoder_seq.add( nn.Conv2D(layers * nf, kernel_size=3, strides=3, padding=current_dim), nn.ELU(), nn.Conv2D(layers * nf, kernel_size=3, strides=3, padding=current_dim), nn.ELU(), ) encoder_seq.add( nn.HybridLambda(lambda F, x: F.reshape(x, shape=(-1, layers * nf * init_dim ** 2))), nn.Dense(nz) ) return encoder_seq
def __init__(self, channels, kernel, stride, bias=True, ifinf=False, *args, **kwargs): super(ConvLayer, self).__init__(*args, **kwargs) with self.name_scope(): if ifinf: self.pad = None self.conv = nn.Conv2D(channels, kernel, strides=stride, padding=kernel // 2, use_bias=bias) else: self.pad = nn.HybridLambda(lambda F, x: F.pad( x, mode='reflect', pad_width=(0, 0, 0, 0, kernel // 2, kernel // 2, kernel // 2, kernel // 2))) self.conv = nn.Conv2D(channels, kernel, strides=stride, padding=0, use_bias=bias) return
def make_ppca_model(self): dtype = get_default_dtype() m = Model() m.w = Variable(shape=(self.K,self.D), initial_value=mx.nd.array(np.random.randn(self.K,self.D))) dot = nn.HybridLambda(function='dot') m.dot = mf.functions.MXFusionGluonFunction(dot, num_outputs=1, broadcastable=False) cov = mx.nd.broadcast_to(mx.nd.expand_dims(mx.nd.array(np.eye(self.K,self.K), dtype=dtype), 0),shape=(self.N,self.K,self.K)) m.z = mf.distributions.MultivariateNormal.define_variable(mean=mx.nd.zeros(shape=(self.N,self.K), dtype=dtype), covariance=cov, shape=(self.N,self.K)) sigma_2 = Variable(shape=(1,), transformation=PositiveTransformation()) m.x = mf.distributions.Normal.define_variable(mean=m.dot(m.z, m.w), variance=sigma_2, shape=(self.N,self.D)) return m
def _concat_conv(channels, kernel=1, stride=1, pad=0, name=None): block = nn.HybridSequential(prefix=name) with block.name_scope(): block.add(nn.HybridLambda(lambda F, x: F.concat(*x, dim=1))) block.add( ConvBundle(channels, kernel=kernel, stride=stride, pad=pad, bias=True, prefix='concat_conv_')) return block
def _upsample_conv(channels, kernel=1, stride=1, pad=0, name=None): block = nn.HybridSequential(prefix=name) with block.name_scope(): block.add( nn.HybridLambda( lambda F, x: F.UpSampling(x, scale=2, sample_type='nearest'), prefix='upsample')) block.add( ConvBundle(channels, kernel=kernel, stride=stride, pad=pad, bias=True, prefix='upsampe_conv_')) return block
def __init__(self, input_nc, output_nc, ngf=64, norm_type='batch', use_dropout=False, netG_arch='resnet_9blocks', padding_type='reflect'): super(CycleGAN_G, self).__init__() norm_layer = get_norm_layer(norm_type=norm_type) use_bias = norm_layer == nn.InstanceNorm if netG_arch == 'resnet_9blocks': n_blocks = 9 elif netG_arch == 'resnet_6blocks': n_blocks = 6 else: raise ValueError('Unknown netG_arch.') self.block_c7s1_64 = nn.Sequential() block_c7s1_64 = [ nn.ReflectionPad2D(3), nn.Conv2D(channels=ngf, in_channels=input_nc, kernel_size=7, strides=1, padding=0, use_bias=use_bias), norm_layer(in_channels=ngf), nn.LeakyReLU(0) ] self.block_c7s1_64.add(*block_c7s1_64) self.block_dk = nn.Sequential() n_downsampling = 2 for i in range(n_downsampling): # add downsampling layers mult = 2**i block_dk = [ nn.Conv2D(in_channels=ngf * mult, channels=ngf * mult * 2, kernel_size=3, strides=2, padding=1, use_bias=use_bias), norm_layer(in_channels=ngf * mult * 2), nn.LeakyReLU(0) ] self.block_dk.add(*block_dk) self.block_Rk = nn.Sequential() mult = 2**n_downsampling for i in range(n_blocks): # add ResNet blocks block_Rk = [ ResidualBlock(ngf * mult, padding_type=padding_type, norm_layer=norm_layer, use_dropout=use_dropout, use_bias=use_bias) ] self.block_Rk.add(*block_Rk) self.block_uk = nn.Sequential() n_upsampling = 2 for i in range(n_upsampling): # add upsampling layers mult = 2**(n_upsampling - i) block_uk = [ nn.Conv2DTranspose(in_channels=ngf * mult, channels=ngf * mult // 2, kernel_size=3, strides=2, padding=1, output_padding=1, use_bias=use_bias), norm_layer(in_channels=ngf * mult // 2), nn.LeakyReLU(0) ] self.block_uk.add(*block_uk) self.block_c7s1_3 = nn.Sequential() block_c7s1_3 = [ nn.ReflectionPad2D(3), nn.Conv2D(in_channels=ngf, channels=output_nc, kernel_size=7, padding=0), nn.HybridLambda('tanh') ] self.block_c7s1_3.add(*block_c7s1_3)
def __init__(self, input_nc, output_nc, ngf=64, n_blocks=6, img_size=256, light=False): assert (n_blocks >= 0) super(ResnetGenerator, self).__init__() self.input_nc = input_nc self.output_nc = output_nc self.ngf = ngf self.n_blocks = n_blocks self.img_size = img_size self.light = light DownBlock = [] DownBlock += [ nn.ReflectionPad2D(3), nn.Conv2D(ngf, kernel_size=7, strides=1, padding=0, use_bias=False, in_channels=input_nc), InstanceNorm2D(), nn.Activation('relu') ] # Down-Sampling n_downsampling = 2 for i in range(n_downsampling): mult = 2**i DownBlock += [ nn.ReflectionPad2D(1), nn.Conv2D(ngf * mult * 2, kernel_size=3, strides=2, padding=0, use_bias=False, in_channels=ngf * mult), InstanceNorm2D(), nn.Activation('relu') ] # Down-Sampling Bottleneck mult = 2**n_downsampling for i in range(n_blocks): DownBlock += [ResnetBlock(ngf * mult, use_bias=False)] # Class Activation Map self.gap_fc = nn.Dense(1, use_bias=False) self.gmp_fc = nn.Dense(1, use_bias=False) self.conv1x1 = nn.Conv2D(ngf * mult, kernel_size=1, strides=1, use_bias=True, in_channels=ngf * mult * 2) self.relu = nn.Activation('relu') # Gamma, Beta block FC = [ nn.Dense(ngf * mult, use_bias=False), nn.Activation('relu'), nn.Dense(ngf * mult, use_bias=False), nn.Activation('relu') ] self.gamma = nn.Dense(ngf * mult, use_bias=False) self.beta = nn.Dense(ngf * mult, use_bias=False) # Up-Sampling Bottleneck self.UpBlock1s = nn.HybridSequential() for i in range(n_blocks): self.UpBlock1s.add(ResnetAdaILNBlock(ngf * mult, use_bias=False)) # Up-Sampling UpBlock2 = [] for i in range(n_downsampling): mult = 2**(n_downsampling - i) UpBlock2 += [ nn.HybridLambda(lambda F, x: F.UpSampling( x, scale=2, sample_type='nearest')), nn.ReflectionPad2D(1), nn.Conv2D(int(ngf * mult / 2), kernel_size=3, strides=1, padding=0, use_bias=False, in_channels=ngf * mult), ILN(int(ngf * mult / 2)), nn.Activation('relu') ] UpBlock2 += [ nn.ReflectionPad2D(3), nn.Conv2D(output_nc, kernel_size=7, strides=1, padding=0, use_bias=False, in_channels=ngf), nn.Activation('tanh') ] self.DownBlock = nn.HybridSequential() self.DownBlock.add(*DownBlock) self.FC = nn.HybridSequential() self.FC.add(*FC) self.UpBlock2 = nn.HybridSequential() self.UpBlock2.add(*UpBlock2)
def __init__(self, levels, channels=128, weighted_add=True, expand_channels=False, **kwargs): super(BiFPNUnit, self).__init__(**kwargs) act_cfg = dict(type='Swish') with self.name_scope(): # top-down branch self.top_down_conv = nn.HybridSequential(prefix='td_') self.top_down_upsampler = nn.HybridSequential( prefix='td.upsampler_') for i, level in enumerate(levels[::-1]): with self.top_down_conv.name_scope(): block = nn.HybridSequential(prefix=f'[{level}]_') with block.name_scope(): if i > 0: block.add( FusionAdd(2, weighted=weighted_add, prefix='fusion2_')) block.add(build_activation(act_cfg)) block.add( _dw_conv_block(int(channels * 2**(len(levels) - i - 1)) if expand_channels else channels, kernel=3, stride=1, pad=1, name='conv_')) self.top_down_conv.add(block) if i < len(levels) - 1: with self.top_down_upsampler.name_scope(): if expand_channels: up = _upsample_conv( channels * 2**(len(levels) - i - 2), name= f'upto.{channels * 2 ** (len(levels) - i - 2)}_' ) else: up = nn.HybridLambda(lambda F, x: F.UpSampling( x, scale=2, sample_type='nearest'), prefix=f'upsample[{i}]') self.top_down_upsampler.add(up) # bottom-up branch self.bottom_up_conv = nn.HybridSequential(prefix='bu_') self.bottom_up_downsampler = nn.HybridSequential( prefix='bu.downsampler_') for i, level in enumerate(levels): with self.bottom_up_conv.name_scope(): block = nn.HybridSequential(prefix=f'[{level}]_') with block.name_scope(): if i == 0: block.add( FusionAdd(2, weighted=weighted_add, prefix='fusion2_')) else: block.add( FusionAdd(3, weighted=weighted_add, prefix='fusion3_')) block.add(build_activation(act_cfg)) block.add( _dw_conv_block( channels * 2**i if expand_channels else channels, kernel=3, stride=1, pad=1, name='conv_')) self.bottom_up_conv.add(block) if i < len(levels) - 1: with self.bottom_up_downsampler.name_scope(): if expand_channels: down = ConvBundle( channels * 2**(len(levels) - i - 2), kernel=1, stride=2, prefix= f'downto.{channels * 2 ** (len(levels) - i - 2)}_' ) else: down = nn.MaxPool2D(pool_size=3, strides=2, padding=1) self.bottom_up_downsampler.add(down)
prenet.collect_params().initialize(mx.init.Xavier(magnitude=2.24), ctx=model_ctx) trees = [] for _ in range(10): _, (data, label) = next(enumerate(train_data)) tree = Tree(lambda: nn.Dense(10)) extend_tree(prenet(data)[0:2], tree) trees.append(tree) forest = contrib.nn.HybridConcurrent() with forest.name_scope(): for tree in trees: forest.add(tree) reshape = nn.HybridLambda(lambda F, x: F.reshape(x, shape=(0, -4, 10, -1))) net = gluon.nn.HybridSequential() with net.name_scope(): net.add(prenet) net.add(forest) net.add(reshape) net.collect_params().initialize(mx.init.Xavier(magnitude=2.24), ctx=model_ctx) error = gluon.loss.SoftmaxCrossEntropyLoss() trainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': 0.01}) acc = mx.metric.Accuracy() for _, (x, y) in enumerate(train_data): data = nd.array(x).as_in_context(model_ctx) label = nd.array(y).as_in_context(model_ctx)