def __init__(self, base_model, num_classes, feature_stride, **kwargs): super(VGGFastRCNNHead, self).__init__(**kwargs) self.feature_stride = feature_stride self.fc_layers = nn.HybridSequential() # Include last 4 vgg feature layers (2 * (fc + dropout)) for layer in base_model.features[-4:]: self.fc_layers.add(layer) self.cls_score = nn.Dense(in_units=4096, units=num_classes, weight_initializer=initializer.Normal(0.01)) self.bbox_pred = nn.Dense(in_units=4096, units=num_classes * 4, weight_initializer=initializer.Normal(0.001))
def _make_deconv_layer(self, num_layers, num_filters, num_kernels): assert num_layers == len(num_filters), \ 'ERROR: num_deconv_layers is different from len(num_deconv_filters)' assert num_layers == len(num_kernels), \ 'ERROR: num_deconv_layers is different from len(num_deconv_filters)' layer = nn.HybridSequential(prefix='final_') with layer.name_scope(): for i in range(num_layers): kernel, padding, output_padding = \ self._get_deconv_cfg(num_kernels[i]) planes = num_filters[i] layer.add( nn.Conv2DTranspose( channels=planes, kernel_size=kernel, strides=2, padding=padding, output_padding=output_padding, use_bias=self.deconv_with_bias, weight_initializer=initializer.Normal(0.001), bias_initializer=initializer.Zero())) layer.add(nn.BatchNorm(gamma_initializer=initializer.One(), beta_initializer=initializer.Zero())) layer.add(nn.Activation('relu')) self.inplanes = planes return layer
def ff(dim, depth): net = gluon.nn.Sequential() net.add(gluon.nn.Dense(dim, activation='swish')) for _ in range(depth): net.add(gluon.nn.Dense(dim, activation='swish')) net.add(gluon.nn.Dense(1, activation='swish')) net.initialize(init=initializer.Normal()) return net
def __init__(self, num_anchors, **kwargs): super(RPNHead, self).__init__(**kwargs) self.num_anchors = num_anchors with self.name_scope(): self.rpn_conv = nn.Conv2D( channels=512, kernel_size=(3, 3), padding=(1, 1), activation='relu', weight_initializer=initializer.Normal(0.01)) self.rpn_cls_score = nn.Conv2D( channels=2 * num_anchors, kernel_size=(1, 1), padding=(0, 0), weight_initializer=initializer.Normal(0.01)) self.rpn_bbox_pred = nn.Conv2D( channels=4 * num_anchors, kernel_size=(1, 1), padding=(0, 0), weight_initializer=initializer.Normal(0.01))
def generate_initializer(init_dict): if init_dict is None: return init.Normal() init_type = init_dict['type'] init_param = init_dict['init_config'] # currently Uniform, Normal, Xavier, MSRAPrelu are supported if init_type == 'Uniform': scale = float(init_param['scale']) return init.Uniform(scale) if init_type == 'Normal': sigma = float(init_param['sigma']) return init.Normal(sigma) # Xavier if init_type == 'Xavier': magnitude = float(init_param['magnitude']) return init.Xavier(magnitude=magnitude) # PReLU if init_type == 'MSRAPrelu': slope = float(init_param['slope']) return init.MSRAPrelu(factor_type='avg', slope=slope)
def __init__(self, fixed_size=True, base_name='resnet50_v1b', pretrained_base=False, pretrained_ctx=cpu(), num_joints=17, num_deconv_layers=3, num_deconv_filters=(256, 256, 256), num_deconv_kernels=(4, 4, 4), final_conv_kernel=1, deconv_with_bias=False, in_channels=3, in_size=(256, 192), **kwargs): super(SimplePoseResNet, self).__init__(**kwargs) assert (in_channels == 3) self.in_size = in_size from gluoncv.model_zoo import get_model base_network = get_model(base_name, pretrained=pretrained_base, ctx=pretrained_ctx, norm_layer=gcv.nn.BatchNormCudnnOff) self.resnet = nn.HybridSequential() if base_name.endswith('v1'): for layer in ['features']: self.resnet.add(getattr(base_network, layer)) else: for layer in [ 'conv1', 'bn1', 'relu', 'maxpool', 'layer1', 'layer2', 'layer3', 'layer4' ]: self.resnet.add(getattr(base_network, layer)) self.deconv_with_bias = deconv_with_bias # used for deconv layers self.deconv_layers = self._make_deconv_layer( num_deconv_layers, num_deconv_filters, num_deconv_kernels, ) self.final_layer = nn.Conv2D( channels=num_joints, kernel_size=final_conv_kernel, strides=1, padding=1 if final_conv_kernel == 3 else 0, weight_initializer=initializer.Normal(0.001), bias_initializer=initializer.Zero())
def __init__(self, ctx=mx.cpu(), pretrained=True, **kwargs): super(FastPose_SE, self).__init__() self.preact = SEResnet('resnet101', norm_layer=norm_layer, **kwargs) self.reload_base() self.shuffle1 = PixelShuffle(2) self.duc1 = DUC(1024, upscale_factor=2, norm_layer=norm_layer, **kwargs) self.duc2 = DUC(512, upscale_factor=2, norm_layer=norm_layer, **kwargs) self.conv_out = nn.Conv2D(channels=opt.nClasses, kernel_size=3, strides=1, padding=1, weight_initializer=initializer.Normal(0.001), bias_initializer=initializer.Zero())
def build_initializer(type, kerasDefaults, constant=0.): if type == 'constant': return initializer.Constant(constant) elif type == 'uniform': return initializer.Uniform(scale=kerasDefaults['maxval_uniform']) elif type == 'normal': return initializer.Normal(sigma=kerasDefaults['stddev_normal']) elif type == 'glorot_uniform': return initializer.Xavier(rnd_type='uniform', factor_type='avg', magnitude=3.) elif type == 'lecun_uniform': return initializers.Xavier(rnd_type='uniform', factor_type='in', magnitude=3.) elif type == 'he_normal': return initializer.Xavier(rnd_type='gaussian', factor_type='in', magnitude=2.)
def __init__(self, base_name, base_attrs=('features', ), num_joints=17, fixed_size=True, pretrained_base=False, pretrained_ctx=cpu(), in_channels=3, in_size=(256, 192), **kwargs): super(MobilePose, self).__init__(**kwargs) assert (in_channels == 3) self.in_size = in_size with self.name_scope(): from gluoncv.model_zoo import get_model base_model = get_model(base_name, pretrained=pretrained_base, ctx=pretrained_ctx) self.features = nn.HybridSequential() if base_name.startswith('mobilenetv2'): self.features.add(base_model.features[:-1]) elif base_name.startswith('mobilenetv3'): self.features.add(base_model.features[:-4]) elif base_name.startswith('mobilenet'): self.features.add(base_model.features[:-2]) else: for layer in base_attrs: self.features.add(getattr(base_model, layer)) self.upsampling = nn.HybridSequential() self.upsampling.add( nn.Conv2D(256, 1, 1, 0, use_bias=False), DUC(512, 2), DUC(256, 2), DUC(128, 2), nn.Conv2D(num_joints, 1, use_bias=False, weight_initializer=initializer.Normal(0.001)), )
def __init__(self, base_name='resnet50_v1b', pretrained_base=False, pretrained_ctx=cpu(), num_joints=19, num_deconv_layers=3, num_deconv_filters=(256, 256, 256), num_deconv_kernels=(4, 4, 4), final_conv_kernel=1, deconv_with_bias=False, **kwargs): super(MultiPoseResNet, self).__init__(**kwargs) base_network = get_model(base_name, pretrained=pretrained_base, ctx=pretrained_ctx) self.resnet = nn.HybridSequential() if base_name.endswith('v1'): for layer in ['features']: self.resnet.add(getattr(base_network, layer)) else: for layer in ['conv1', 'bn1', 'relu', 'maxpool', 'layer1', 'layer2', 'layer3', 'layer4']: self.resnet.add(getattr(base_network, layer)) self.deconv_with_bias = deconv_with_bias # used for deconv layers self.deconv_layers = self._make_deconv_layer( num_deconv_layers, num_deconv_filters, num_deconv_kernels, ) self.final_layer = nn.Conv2D( channels=num_joints*3, kernel_size=final_conv_kernel, strides=1, prefix='final_', padding=1 if final_conv_kernel == 3 else 0, weight_initializer=initializer.Normal(0.001), bias_initializer=initializer.Zero() )
@use_np @with_environment('MXNET_ENGINE_TYPE', 'NaiveEngine') def test_18934_empty_leaky_relu(): arr = np.random.rand(0,2) arr_grad = np.empty_like(arr) autograd.mark_variables([arr], [arr_grad]) with autograd.record(): res = npx.leaky_relu(arr) res.backward() @use_np @pytest.mark.parametrize('initializer',[ 'zeros', 'ones', initializer.Constant(3), initializer.Uniform(), initializer.Normal(), initializer.Orthogonal(), initializer.Orthogonal(rand_type='normal'), initializer.Xavier(), initializer.Xavier(rnd_type='gaussian'), initializer.MSRAPrelu(), initializer.MSRAPrelu(factor_type='in'), initializer.MSRAPrelu(factor_type='out'), initializer.LSTMBias(), ]) @pytest.mark.parametrize('dtype', [ 'float32', 'float64' ]) def test_19118(initializer, dtype): net = gluon.nn.Dense(16, in_units=16) net.cast(dtype)
def __init__(self, basenetwork='resnet50_v2', pretrained="True", feature_channels=512, classes=751, laststride=2, withpcb='True', partnum=6, feature_weight_share=False, withrpp='True', **kwargs): super(PCBRPPNet, self).__init__(**kwargs) basenetwork = eval(basenetwork) self.withpcb = withpcb self.withrpp = withrpp if self.withrpp and not self.withpcb: raise "If withrpp is True, with pcb must be True." self.feature_weight_share = feature_weight_share self.partnum = partnum self.conv = basenetwork(pretrained=pretrained, laststride=laststride, ctx=cpu()) if not pretrained: self.conv.collect_params().initialize(init=init.Xavier(), ctx=cpu()) self.pool = nn.GlobalAvgPool2D() self.dropout = nn.Dropout(rate=0.5) if not self.withpcb or self.feature_weight_share: self.feature = nn.HybridSequential(prefix='') with self.feature.name_scope(): self.feature.add( nn.Dense(feature_channels, activation=None, use_bias=False, flatten=True)) self.feature.add(nn.BatchNorm()) self.feature.add(nn.LeakyReLU(alpha=0.1)) self.feature.hybridize() self.classifier = nn.Dense(classes, use_bias=False) self.feature.collect_params().initialize(init=init.Xavier(), ctx=cpu()) self.classifier.collect_params().initialize( init=init.Normal(0.001), ctx=cpu()) else: for pn in range(self.partnum): tmp_feature = nn.Dense(feature_channels, activation=None, use_bias=False, flatten=True) tmp_classifier = nn.Dense(classes, use_bias=False) tmp_feature.collect_params().initialize(init=init.Xavier(), ctx=cpu()) tmp_classifier.collect_params().initialize( init=init.Normal(0.001), ctx=cpu()) setattr(self, 'feature%d' % (pn + 1), tmp_feature) setattr(self, 'classifier%d' % (pn + 1), tmp_classifier) if self.withrpp: # from ..init.rppinit import RPP_Init # rpp_init = RPP_Init(mean=0.0, sigma=0.001) self.rppscore = nn.Conv2D(self.partnum, kernel_size=1, use_bias=False) self.rppscore.collect_params().initialize(init=init.One(), ctx=cpu())
head_grads=nd.ones_like(mixed_scores))[0] return grad def gradient_penalty(gradient): gradient = gradient.reshape(gradient.shape[0], -1) gradient_norm = nd.norm(gradient, ord=2, axis=1) penalty = nd.mean((gradient_norm - 1) ** 2) return penalty # %% # -- Initialize parameters gen = Generator(z_dim=Z_DIM) gen.initialize(init=initializer.Normal(0.02), ctx=mx_ctx) # %% crit = Critic() crit.initialize(init=initializer.Normal(0.02), ctx=mx_ctx) # %% # -- Print summary before hybridizing z = nd.random.randn(1, Z_DIM, 1, 1, ctx=mx_ctx[0]) print(gen) gen.summary(z) # %% xhat = nd.random.randn(1, 1, 28, 28, ctx=mx_ctx[0]) print(crit)
# W = nd.random.normal(scale=1,shape=(num_input,num_outputs)) # b = nd.zeros(shape=num_outputs) # W.attach_grad() # b.attach_grad() # 定义模型、分类模型、损失函数 def softmax(X): x_exp = X.exp() partition = x_exp.sum(axis=1,keepdims = True) return x_exp/partition net = nn.Sequential() net.add(nn.Dense(10)) # 输出是10个分类 net.initialize(init.Normal(sigma=0.01)) def cross_entropy(y_hat,y): return -nd.pick(y_hat,y).log() def accuracy(y_hat,y): return (y_hat.argmax(axis=1) == y.astype('float32')).mean().asscalar() num_epoch=5 trianer = gluon.Trainer(net.collect_params(),'sgd',{'learning_rate':0.1}) # 这里把这个函数展开来写 # d2l.train_ch3(net,train_iter,test_iter,cross_entropy,num_epoch,batch_size,[W,b],lr)
nn.BatchNorm(), nn.Activation('relu'), nn.Conv2DTranspose(ngf, 4, 2, 1, use_bias=False), nn.BatchNorm(), nn.Activation('relu'), nn.Conv2DTranspose(nchannels, 4, 2, 1, use_bias=False, activation='tanh')) def forward(self, input): return self.main(input) netG = Generator() netG.initialize(init=initializer.Normal(0.02), ctx=ctx) # print(netG) class Discriminator(nn.Block): def __init__(self): super(Discriminator, self).__init__() self.main = nn.Sequential() self.main.add( nn.Conv2D(ndf, 4, 2, 1, use_bias=False), nn.LeakyReLU(0.2), nn.Conv2D(ndf * 2, 4, 2, 1, use_bias=False), nn.BatchNorm(), nn.LeakyReLU(0.2), nn.Conv2D(ndf * 4, 4, 2, 1, use_bias=False), nn.BatchNorm(), nn.LeakyReLU(0.2), nn.Conv2D(ndf * 8, 4, 2, 1, use_bias=False), nn.BatchNorm(), nn.LeakyReLU(0.2), nn.Conv2D(1, 4, 1, 0, use_bias=False, activation='sigmoid'))
use_bias=False), nn.BatchNorm(in_channels=output_dim), nn.LeakyReLU(alpha=0.2)) else: layer.add( nn.Conv2D(in_channels=input_dim, channels=output_dim, kernel_size=kernel_size, strides=strides)) return layer # %% # -- Initialize parameters gen = Generator(z_dim=Z_DIM) gen.initialize(init=initializer.Normal(0.02), ctx=mx_ctx) # %% disc = Discriminator() disc.initialize(init=initializer.Normal(0.02), ctx=mx_ctx) # %% # -- Print summary before hybridizing z = nd.random.randn(1, Z_DIM, 1, 1, ctx=mx_ctx[0]) print(gen) gen.summary(z) # %% xhat = nd.random.randn(1, 1, 28, 28, ctx=mx_ctx[0]) print(disc)