def __init__(self, features, config, **kwargs): super().__init__(**kwargs) self.feature_layers = [4, 5, 6, 7] self.feature_dims = [64, 128, 256, 512] self.features = features with self.name_scope(): # self.backbone = vision.resnet50_v1() self.add_layers('reduce_dim', conv_bn_relu(64, 1), conv_bn_relu(64, 1), conv_bn_relu(64, 1), conv_bn_relu(64, 1)) self.add_layers( 'deconv', nn.Conv2DTranspose( 64, 4, strides=2, padding=1, weight_initializer=mx.initializer.MSRAPrelu(slope=0.1)), nn.Conv2DTranspose( 64, 4, strides=2, padding=1, weight_initializer=mx.initializer.MSRAPrelu(slope=0.1)), nn.Conv2DTranspose( 64, 4, strides=2, padding=1, weight_initializer=mx.initializer.MSRAPrelu(slope=0.1))) self.add_layers('pred', self._prediction_head(), self._prediction_head(), self._prediction_head(), self._prediction_head()) self.flow = nn.HybridSequential(prefix='flow') self.flow.add( nn.Conv2D(64, 7, padding=3, weight_initializer=Xavier(rnd_type='gaussian', magnitude=2))) self.flow.add(nn.LeakyReLU(0.1)) self.flow.add( nn.Conv2D(64, 7, padding=3, weight_initializer=Xavier(rnd_type='gaussian', magnitude=2))) self.flow.add(nn.LeakyReLU(0.1)) self.flow.add( nn.Conv2D(64, 7, padding=3, weight_initializer=Xavier(rnd_type='gaussian', magnitude=2))) self.flow.add(nn.LeakyReLU(0.1))
def __init__(self, features, config, **kwargs): super().__init__(**kwargs) self.feature_layers = [4, 5, 6, 7] self.feature_dims = [64, 128, 256, 512] self.features = features self.dilation = get_param(config, 'network.dilation', 1) with self.name_scope(): # self.backbone = vision.resnet50_v1() self.reduce_dim = nn.HybridSequential() self.reduce_dim.add(nn.Conv2D(64, 1)) self.reduce_dim.add(nn.BatchNorm()) self.reduce_dim.add(nn.Activation('relu')) self.reduce_dim_2 = nn.HybridSequential() self.reduce_dim_2.add(nn.Conv2D(64, 1)) self.reduce_dim_2.add(nn.BatchNorm()) self.upsampler = Upsample(64, 2) self.flow = nn.HybridSequential(prefix='flow') self.flow.add( nn.Conv2D(64, 7, padding=3 * self.dilation, dilation=self.dilation, weight_initializer=Xavier(rnd_type='gaussian', magnitude=2))) self.flow.add(nn.LeakyReLU(0.1)) self.flow.add( nn.Conv2D(32, 7, padding=3 * self.dilation, dilation=self.dilation, weight_initializer=Xavier(rnd_type='gaussian', magnitude=2))) self.flow.add(nn.LeakyReLU(0.1)) self.flow.add( nn.Conv2D(16, 7, padding=3 * self.dilation, dilation=self.dilation, weight_initializer=Xavier(rnd_type='gaussian', magnitude=2))) self.flow.add(nn.LeakyReLU(0.1)) self.flow.add( nn.Conv2D(2, 7, padding=3 * self.dilation, dilation=self.dilation, weight_initializer=Xavier(rnd_type='gaussian', magnitude=2)))
def _conv2d_bn(filter, kernel, dilation, padding, stride, num_sync_bn_devices=-1): """A common conv-bn-leakyrelu cell""" cell = nn.HybridSequential(prefix='') cell.add( nn.Conv2D(filter, kernel_size=kernel, dilation=dilation, strides=stride, padding=padding, weight_initializer=Xavier(rnd_type='gaussian', factor_type='out', magnitude=2), bias_initializer='zeros')) if num_sync_bn_devices < 1: cell.add(nn.BatchNorm(epsilon=1e-5, momentum=0.9)) else: cell.add( gluon.contrib.nn.SyncBatchNorm(epsilon=1e-5, momentum=0.9, num_devices=num_sync_bn_devices)) cell.add(nn.Activation('relu')) return cell
def __init__(self, bert_out_dim, params=None): super(CoAttention, self).__init__(bert_out_dim) with self.name_scope(): self.w4c = gluon.nn.Dense(units=1, flatten=False, weight_initializer=Xavier(), use_bias=False) self.w4q = gluon.nn.Dense(units=1, flatten=False, weight_initializer=Xavier(), use_bias=False) self.w4mlu = self.params.get('linear_kernel', shape=(1, 1, int(bert_out_dim)), init=mx.init.Xavier()) self.bias = self.params.get('coattention_bias', shape=(1, ), init=mx.init.Zero())
def __init__(self, batchSize): self.net = SSDv1() self.net.initialize(init=Xavier(), ctx=self.ctx) self.batchSize = batchSize self.trainIter = image.ImageDetIter(batch_size=self.batchSize, data_shape=(3, 300, 300), path_imgrec='utils/TrainY.rec', path_imgidx='utils/TrainY.idx',) self.trainer = gluon.Trainer(self.net.collect_params(), 'sgd', {'learning_rate': 0.1, 'wd': 5e-4})
def __init__(self, **kwargs): super(CoAttention, self).__init__(**kwargs) with self.name_scope(): self.w4c = gluon.nn.Dense(units=1, flatten=False, weight_initializer=Xavier(), use_bias=False) self.w4q = gluon.nn.Dense(units=1, flatten=False, weight_initializer=Xavier(), use_bias=False) self.w4mlu = self.params.get('linear_kernel', shape=(1, 1, opt.emb_encoder_conv_channels), init=mx.init.Xavier()) self.bias = self.params.get('coattention_bias', shape=(1, ), init=mx.init.Zero())
def __init__(self, **kwargs): super(CoAttention, self).__init__(**kwargs) with self.name_scope(): self.w4c = gluon.nn.Dense( units=1, flatten=False, weight_initializer=Xavier(), use_bias=False ) self.w4q = gluon.nn.Dense( units=1, flatten=False, weight_initializer=Xavier(), use_bias=False ) self.w4mlu = self.params.get( 'linear_kernel', shape=(1, 1, EMB_ENCODER_CONV_CHANNELS), init=mx.init.Xavier()) self.bias = self.params.get( 'coattention_bias', shape=(1,), init=mx.init.Zero())
def __init__(self, freeze=False, batch_norm=False, **kwargs): super(E2FAR, self).__init__(**kwargs) with self.name_scope(): self.layers = [2, 2, 3, 3] self.filters = [64, 128, 256, 512] self.hidden_units = [4096, 1024] self.backbone = self._make_features([2, 2, 3, 3], [64, 128, 256, 512], batch_norm) self.extra_backbone = self._make_features([3], [512], batch_norm) self.conv6 = gluon.nn.Conv2D(512, kernel_size=5, strides=2, padding=1, weight_initializer=Xavier( rnd_type='gaussian', factor_type='out', magnitude=2), bias_initializer='zeros') self.conv7 = gluon.nn.Conv2D(512, kernel_size=1, weight_initializer=Xavier( rnd_type='gaussian', factor_type='out', magnitude=2), bias_initializer='zeros') self.conv8 = gluon.nn.Conv2D(512, kernel_size=1, weight_initializer=Xavier( rnd_type='gaussian', factor_type='out', magnitude=2), bias_initializer='zeros') self.shape_regressor = self._make_prediction(out_dim=199) self.exp_regressor = self._make_prediction(out_dim=29) if freeze: for _, w in self.backbone.collect_params().items(): w.grad_req = 'null' for _, w in self.extra_backbone.collect_params().items(): w.grad_req = 'null'
def _conv2d(filter, kernel, dilation, padding, stride): """A common conv-bn-leakyrelu cell""" cell = nn.HybridSequential(prefix='') cell.add(nn.Conv2D(filter, kernel_size=kernel, dilation=dilation, strides=stride, padding=padding, weight_initializer=Xavier(rnd_type='gaussian', factor_type='out', magnitude=2), bias_initializer='zeros')) cell.add(nn.Activation('relu')) return cell
def __init__(self, channels, **kwargs): super().__init__(**kwargs) with self.name_scope(): self.deconv = nn.Conv2DTranspose(channels, 4, strides=2, padding=1, weight_initializer=Xavier( rnd_type='gaussian', magnitude=2)) self.reduce_dim = nn.Conv2D(channels, 1, use_bias=False, weight_initializer=Xavier( rnd_type='gaussian', magnitude=2)) self.conv = nn.Conv2D(channels, 3, padding=1, weight_initializer=Xavier( rnd_type='gaussian', magnitude=2))
def init_model(self, is_train=True): """ Initialized the model :param is_train: :return: """ if self.args.pretrained_mode == 0 and os.path.exists( self.args.model_path): # load imagenet pretrained model print('load pretrained model from %s...' % self.args.model_path) self.inference.init_imagenet_params(self.args.model_path, self.ctx) elif self.args.pretrained_mode == 1 and os.path.exists( self.args.model_path): # load webface pretrained model print('load pretrained model from %s...' % self.args.model_path) self.inference.init_convs_params(self.args.model_path, self.ctx) elif self.args.pretrained_mode == 2 and os.path.exists( self.args.model_path): print('load pretrained model from %s...' % self.args.model_path) self.inference.load_parameters(self.args.model_path, ctx=self.ctx, allow_missing=True) self.inference.init_extra_params(self.ctx) elif self.args.pretrained_mode == 3 and os.path.exists( self.args.model_path): print('load pretrained model from %s...' % self.args.model_path) self.inference.load_parameters(self.args.model_path, ctx=self.ctx) model_name, cur_epoch, cur_iter = (os.path.splitext( os.path.basename(self.args.model_path))[0]).split('-') self.args.start_epoch = int(cur_epoch) self.cur_iter = int(cur_iter) self.cur_epoch = int(cur_epoch) elif self.args.model_path.endswith('.params') or not is_train: # load from the path print('load model from the %s...' % self.args.model_path) # self.inference.load_parameters(self.args.model_path, ctx=self.ctx, ignore_extra=True) self.inference.load_parameters(self.args.model_path, ctx=self.ctx, ignore_extra=True) elif self.args.start_epoch > 0: # load from the previous checkpoint model_path = os.path.join( self.args.ckpt_dir, '%s-epoch-%d.params' % (self.args.arch, self.args.start_epoch)) print('load the model for the epoch [%d] from %s...' % (self.args.start_epoch, model_path)) self.inference.load_parameters(model_path, self.ctx) else: # random initialize print('initialize the model using Xavier initializer...') self.inference.initialize(Xavier(rnd_type='gaussian', factor_type='out', magnitude=2), ctx=self.ctx)
def _make_features(self, layers, filters, batch_norm, step): featurizer = nn.HybridSequential(prefix='') count = 0 for i, num in enumerate(layers): for _ in range(num): if count not in step_spec[step]: conv_layer = nn.QConv2D(filters[i], kernel_size=3, padding=1, weight_initializer=Xavier( rnd_type='gaussian', factor_type='out', magnitude=2), bias_initializer='zeros', bits=1, apply_scaling=True) featurizer.add(conv_layer) featurizer.add(nn.Dropout(rate=0.25)) featurizer.add(nn.Activation('relu')) else: conv_layer = nn.Conv2D(filters[i], kernel_size=3, padding=1, weight_initializer=Xavier( rnd_type='gaussian', factor_type='out', magnitude=2), bias_initializer='zeros') featurizer.add(conv_layer) featurizer.add(nn.Dropout(rate=0.25)) featurizer.add(nn.Activation('relu')) count += 1 if batch_norm: featurizer.add(nn.BatchNorm()) featurizer.add(nn.MaxPool2D(strides=2)) return featurizer
def get_base_net(self): """ 获取base net,默认是mobilenet v2 :return: base net,基础网络 """ base_net = get_model('mobilenet1.0', pretrained=True) with base_net.name_scope(): base_net.output = Dense(units=self.n_class) # 全连接层 base_net.output.initialize(Xavier(), ctx=self.ctx) # 初始化 base_net.collect_params().reset_ctx(self.ctx) base_net.hybridize() return base_net
def __init__(self, layers, filters, batch_norm=False, **kwargs): super(VGGAtrousBase, self).__init__(**kwargs) assert len(layers) == len(filters) self.init = { 'weight_initializer': Xavier(rnd_type='gaussian', factor_type='out', magnitude=2), 'bias_initializer': 'zeros' } with self.name_scope(): # we use pre-trained weights from caffe, initial scale must change init_scale = mx.nd.array([0.229, 0.224, 0.225]).reshape( (1, 3, 1, 1)) * 255 self.init_scale = self.params.get_constant('init_scale', init_scale) self.stages = nn.HybridSequential() for l, f in zip(layers, filters): stage = nn.HybridSequential(prefix='') with stage.name_scope(): for _ in range(l): stage.add( nn.Conv2D(f, kernel_size=3, padding=1, **self.init)) if batch_norm: stage.add(nn.BatchNorm()) stage.add(nn.Activation('relu')) self.stages.add(stage) # self.stages have [stage1, stage2, stage3, stage4, stage5] now # the stride are [1 , 2 , 4 , 8 , 16] before max pool. # use dilated convolution instead of dense layers stage = nn.HybridSequential(prefix='dilated_') with stage.name_scope(): stage.add( nn.Conv2D(1024, kernel_size=3, padding=6, dilation=6, **self.init)) if batch_norm: stage.add(nn.BatchNorm()) stage.add(nn.Activation('relu')) stage.add(nn.Conv2D(1024, kernel_size=1, **self.init)) if batch_norm: stage.add(nn.BatchNorm()) stage.add(nn.Activation('relu')) self.stages.add(stage) # self.stages ==>[stage1, ..., stage5, stage6(the dense layers in vgg)]. # the stride of stage6 is 32. # normalize layer for 4-th and 5-th stage self.norm4 = Normalize(filters[3], 10) self.norm5 = Normalize(filters[4], 8)
def __init__(self, features, **kwargs): super().__init__(**kwargs) self.feature_layers = [4, 5, 6, 7] self.feature_dims = [64, 128, 256, 512] self.features = features with self.name_scope(): # self.backbone = vision.resnet50_v1() self.reduce_dim = nn.Conv2D(1024, 1, use_bias=False) self.flow = nn.HybridSequential(prefix='flow') self.flow.add( nn.Conv2D(1024, 3, padding=1, weight_initializer=Xavier(rnd_type='gaussian', magnitude=2))) self.flow.add(nn.Activation('relu')) self.flow.add( nn.Conv2D(1024, 3, padding=1, weight_initializer=Xavier(rnd_type='gaussian', magnitude=2))) self.flow.add(nn.Activation('relu')) self.flow.add( nn.Conv2D(512, 3, padding=1, weight_initializer=Xavier(rnd_type='gaussian', magnitude=2))) self.flow.add(nn.Activation('relu')) self.upbranch4 = TopDownBranch(self.feature_dims[2]) self.upbranch3 = TopDownBranch(self.feature_dims[1]) self.upbranch2 = TopDownBranch(self.feature_dims[0]) self.output5 = nn.Conv2D(2, 3, padding=1) self.output4 = nn.Conv2D(2, 3, padding=1) self.output3 = nn.Conv2D(2, 3, padding=1) self.output2 = nn.Conv2D(2, 3, padding=1)
def get_base_net(ctx): """ 获取base net,默认是mobilenet v2 :param ctx: 运行环境,cpu or gpu,默认cpu :return: base net,基础网络 """ base_net = get_model('mobilenet1.0', pretrained=True) with base_net.name_scope(): base_net.output = Dense(units=27) # 全连接层 base_net.output.initialize(Xavier(), ctx=ctx) # 初始化 base_net.collect_params().reset_ctx(ctx) base_net.hybridize() return base_net
def __init__(self, bert_out_dim, concat_out=True, params=None): super(CoAttention, self).__init__("co_attention") self.concat_out = concat_out with self.name_scope(): self.w4c = gluon.nn.Dense(units=1, flatten=False, weight_initializer=Xavier(), use_bias=False) self.w4q = gluon.nn.Dense(units=1, flatten=False, weight_initializer=Xavier(), use_bias=False) self.w4mlu = self.params.get('linear_kernel', shape=(1, 1, bert_out_dim), init=mx.init.Xavier()) self.bias = self.params.get('coattention_bias', shape=(1, ), init=mx.init.Zero()) if not self.concat_out: self.out_weight = self.params.get('weight_of_output', shape=(1, 4), init=mx.init.Xavier())
def __init__(self, num_heads, **kwargs): super(SelfAttention, self).__init__(**kwargs) with self.name_scope(): self.attention = MultiHeadAttentionCell( num_heads=num_heads, base_cell=DotProductAttentionCell(scaled=True, dropout=opt.layers_dropout, use_bias=False), query_units=opt.emb_encoder_conv_channels, key_units=opt.emb_encoder_conv_channels, value_units=opt.emb_encoder_conv_channels, use_bias=False, weight_initializer=Xavier())
def train(params, loader, model=None): epoch = params.get('epoch', 10) verbose = params.get("verbose", True) batch_size = params.get("batch_size", 32) if model is None: class_name = params["class_name"] layer_num = params.get("layer_num", 5) class_num = params.get("class_num", 3) s = params.get("s", 4) b = params.get("b", 2) yolo = Yolo(layer_num, class_num, s=s, b=b, class_name=class_name) yolo.initialize(init=Xavier(magnitude=0.02)) else: print("model load finish") layer_num = model.layer_num class_num = model.class_num s = model.s b = model.b yolo = model if verbose: print("train params: \n\tepoch:%d \n\tlayer_num:%d \n\tclass_num:%d \n\ts:%d \n\tb:%d" % \ (epoch, layer_num, class_num, s, b)) ngd = optimizer.SGD(momentum=0.7, learning_rate=0.005) trainer = gluon.Trainer(yolo.collect_params(), ngd) for ep in range(epoch): loader.reset() mean_loss = 0 t1 = time() for i, batch in enumerate(loader): x = batch.data[0] y = batch.label[0].reshape((-1, 5)) y = translate_y(y, yolo.s, yolo.b, yolo.class_num) y = nd.array(y) with autograd.record(): loss_func = TotalLoss(s=s, c=class_num, b=b) ypre = yolo(x) # (32,output_dim) loss = nd.mean(loss_func(ypre, y)) mean_loss += loss.asscalar() loss.backward() trainer.step(batch_size) t2 = time() if verbose: print("epoch:%d/%d loss:%.5f time:%4f" % (ep + 1, epoch, mean_loss / 32, t2 - t1), flush=True) print() return yolo
def _make_features(self, layers, filters, batch_norm): featurizer = nn.HybridSequential(prefix='') for i, num in enumerate(layers): for _ in range(num): featurizer.add(nn.Conv2D(filters[i], kernel_size=3, padding=1, weight_initializer=Xavier(rnd_type='gaussian', factor_type='out', magnitude=2), bias_initializer='zeros')) if batch_norm: featurizer.add(nn.BatchNorm()) featurizer.add(nn.Activation('relu')) featurizer.add(nn.MaxPool2D(strides=2)) return featurizer
def __init__(self): super(Matting_Decoder,self).__init__() self.trans = nn.HybridSequential(prefix='') self.trans.add(nn.Conv2D(channels=512,kernel_size=1)) self.trans.add(nn.BatchNorm()) channels = [512,256,128,64,64] self.dec_layers = [] for i,c in enumerate(channels): block = nn.HybridSequential(prefix='decove_{0}'.format(6-i)) block.add(nn.Conv2D(channels=c,kernel_size=5,padding=2, weight_initializer=Xavier(rnd_type='gaussian', factor_type='out', magnitude=2), bias_initializer='zeros')) block.add(nn.BatchNorm()) block.add(nn.Activation('relu')) self.dec_layers.append(block) self.alpha_block = nn.HybridSequential() self.alpha_block.add(nn.Conv2D(channels=1,kernel_size=5,padding=2, weight_initializer=Xavier(rnd_type='gaussian', factor_type='out', magnitude=2), bias_initializer='zeros')) self.alpha_block.add(nn.BatchNorm()) self.alpha_block.add(nn.Activation('relu'))
def __init__(self, kernel_size, num_filters, conv_layers, num_heads, total_layers, sub_layer_idx, **kwargs): super(OneEncoderBlock, self).__init__(**kwargs) self.position_encoder = PositionEncoder() self.convs = gluon.nn.HybridSequential() with self.convs.name_scope(): for _ in range(conv_layers): one_conv_module = gluon.nn.HybridSequential() with one_conv_module.name_scope(): one_conv_module.add(gluon.nn.LayerNorm(epsilon=1e-06)) one_conv_module.add(gluon.nn.Dropout(opt.layers_dropout)) one_conv_module.add( DepthwiseConv(kernel_size=kernel_size, num_filters=num_filters, input_channels=num_filters)) one_conv_module.add( StochasticDropoutLayer( dropout=(sub_layer_idx / total_layers) * (1 - opt.p_l))) sub_layer_idx += 1 self.convs.add(one_conv_module) with self.name_scope(): self.dropout = gluon.nn.Dropout(opt.layers_dropout) self.attention = SelfAttention(num_heads=num_heads) self.attention_dropout = StochasticDropoutLayer( (sub_layer_idx / total_layers) * (1 - opt.p_l)) sub_layer_idx += 1 self.attention_layer_norm = gluon.nn.LayerNorm(epsilon=1e-06) self.positionwise_ffn = gluon.nn.HybridSequential() with self.positionwise_ffn.name_scope(): self.positionwise_ffn.add(gluon.nn.LayerNorm(epsilon=1e-06)) self.positionwise_ffn.add( gluon.nn.Dropout(rate=opt.layers_dropout)) self.positionwise_ffn.add( gluon.nn.Dense(units=opt.emb_encoder_conv_channels, activation='relu', use_bias=True, weight_initializer=MSRAPrelu(), flatten=False)) self.positionwise_ffn.add( gluon.nn.Dense(units=opt.emb_encoder_conv_channels, use_bias=True, weight_initializer=Xavier(), flatten=False)) self.positionwise_ffn.add( StochasticDropoutLayer(dropout=(sub_layer_idx / total_layers) * (1 - opt.p_l)))
def _init_weight(self, name, arr): if name in self._kwargs.keys(): init_params = self._kwargs[name] for (k, v) in init_params.items(): if k.lower() == "normal": random.normal(0, v, out=arr) elif k.lower() == "uniform": random.uniform(-v, v, out=arr) elif k.lower() == "orthogonal": raise NotImplementedError("Not support at the moment") elif k.lower() == "xavier": xa = Xavier(v[0], v[1], v[2]) xa(name, arr) else: raise NotImplementedError("Not support")
def __init__(self,spec,stage): super(Encoder_Decoder,self).__init__() self.stage = stage self.encoder = Matting_Encoder(spec=spec) self.decoder = Matting_Decoder() self.refine = nn.HybridSequential(prefix='refine') channels = [64,64,64,1] with self.refine.name_scope(): for i,c in enumerate(channels): self.refine.add(nn.Conv2D(channels=64,kernel_size=3, weight_initializer=Xavier(), bias_initializer='zeros')) self.refine.add(nn.BatchNorm()) self.refine.add(nn.Activation('relu'))
def __init__(self, num_heads, **kwargs): super(SelfAttention, self).__init__(**kwargs) with self.name_scope(): self.attention = MultiHeadAttentionCell( num_heads=num_heads, base_cell=DotProductAttentionCell( scaled=True, dropout=0.1, use_bias=False ), query_units=EMB_ENCODER_CONV_CHANNELS, key_units=EMB_ENCODER_CONV_CHANNELS, value_units=EMB_ENCODER_CONV_CHANNELS, use_bias=False, weight_initializer=Xavier() )
def __init__(self, features, config, **kwargs): super().__init__(**kwargs) self.scale = get_param(config, 'network.scale') with self.name_scope(): self.flow = nn.HybridSequential(prefix='flow') act_param = get_param(config, 'network.activation', dict()) act_func = self._builder(lambda: nn.Activation('relu'), **act_param) weight_init_param = get_param(config, 'network.weight_init', dict()) weight_init_func = self._builder( lambda: Xavier(rnd_type='gaussian', magnitude=2), **weight_init_param) self.flow.add( nn.Conv2D(32, 7, padding=3, weight_initializer=weight_init_func())) self.flow.add(act_func()) self.flow.add( nn.Conv2D(64, 7, padding=3, weight_initializer=weight_init_func())) self.flow.add(act_func()) self.flow.add( nn.Conv2D(32, 7, padding=3, weight_initializer=weight_init_func())) self.flow.add(act_func()) self.flow.add( nn.Conv2D(16, 7, padding=3, weight_initializer=weight_init_func())) self.flow.add(act_func()) self.flow.add( nn.Conv2D(2, 7, padding=3, weight_initializer=weight_init_func()))
def train2(params, loader: BaseDataLoader, model=None): epoch = params.get('epoch', 10) verbose = params.get("verbose", True) batch_size = params.get("batch_size", 32) if model is None: layer_num = params.get("layer_num", 5) class_num = params.get("class_num", 3) s = params.get("s", 4) b = params.get("b", 2) yolo = Yolo(layer_num, class_num, s=s, b=b) yolo.initialize(init=Xavier(magnitude=0.02)) else: print("model load finish") layer_num = model.layer_num class_num = model.class_num s = model.s b = model.b yolo = model if verbose: print("train params: \n\tepoch:%d \n\tlayer_num:%d \n\tclass_num:%d \n\ts:%d \n\tb:%d" % \ (epoch, layer_num, class_num, s, b)) ngd = optimizer.SGD(momentum=0.7, learning_rate=0.0025) trainer = gluon.Trainer(yolo.collect_params(), ngd) for ep in range(epoch): loss = 0 all_batch = int(loader.data_number() / batch_size) t1 = time() for _ in range(all_batch): x, y = loader.next_batch(batch_size) with autograd.record(): loss_func = TotalLoss(s=s, c=class_num, b=b) ypre = yolo(x) # (32,output_dim) loss = nd.mean(loss_func(ypre, y)) loss.backward() trainer.step(batch_size) t2 = time() if verbose: print("epoch:%d/%d loss:%.5f time:%4f" % (ep + 1, epoch, loss.asscalar(), t2 - t1), flush=True) return yolo
def __init__(self, in_channels, out_channels, kernel_size, strides, padding, use_bias, use_bn, bn_use_global_stats, **kwargs): super(VGGConv, self).__init__(**kwargs) self.use_bn = use_bn with self.name_scope(): self.conv = nn.Conv2D(channels=out_channels, kernel_size=kernel_size, strides=strides, padding=padding, use_bias=use_bias, weight_initializer=Xavier( rnd_type='gaussian', factor_type='out', magnitude=2), in_channels=in_channels) if self.use_bn: self.bn = nn.BatchNorm(in_channels=out_channels, use_global_stats=bn_use_global_stats) self.activ = nn.Activation('relu')
def __init__(self, layers, filters, batch_norm=False, **kwargs): super(VGGBase, self).__init__(**kwargs) assert len(layers) == len(filters) self.init = { 'weight_initializer': Xavier(rnd_type='gaussian', factor_type='out', magnitude=2), 'bias_initializer': 'zeros' } self.layers = layers self.batch_norm = batch_norm with self.name_scope(): self.stages = nn.HybridSequential() for l, f in zip(layers, filters): stage = nn.HybridSequential(prefix='') with stage.name_scope(): for _ in range(l): stage.add( nn.Conv2D(f, kernel_size=3, padding=1, **self.init)) if batch_norm: stage.add(nn.BatchNorm()) stage.add(nn.Activation('relu')) self.stages.add(stage) # use convolution instead of dense layers stage = nn.HybridSequential(prefix='fc_') with stage.name_scope(): stage.add( nn.Conv2D(1024, kernel_size=3, padding=1, **self.init)) # fc6 if batch_norm: stage.add(nn.BatchNorm()) stage.add(nn.Activation('relu')) stage.add(nn.Conv2D(1024, kernel_size=1, **self.init)) # fc7 if batch_norm: stage.add(nn.BatchNorm()) stage.add(nn.Activation('relu')) self.stages.add(stage)
def __init__(self, features, config, **kwargs): super().__init__(**kwargs) self.feature_layers = [4, 5, 6, 7] self.feature_dims = [64, 128, 256, 512] self.features = features config = Reader(config) with self.name_scope(): # self.backbone = vision.resnet50_v1() self.reduce_dim = nn.HybridSequential() self.reduce_dim.add(nn.Conv2D(64, 1)) self.reduce_dim.add(nn.BatchNorm()) self.reduce_dim.add(nn.Activation('relu')) channels = config.network.flow.channels.get([64, 32, 16, 2]) self.flow = nn.HybridSequential(prefix='flow') for i, c in enumerate(channels): if i != 0: self.flow.add(nn.LeakyReLU(0.1)) self.flow.add( nn.Conv2D(c, 7, padding=3, weight_initializer=Xavier(rnd_type='gaussian', magnitude=2)))