def setup_model(phrase_net, image_net): if image_net == 'vgg': vis_cnn = L.VGG16Layers() elif image_net == 'resnet': vis_cnn = L.ResNet50Layers() else: pass wo_image = (image_net is None) if phrase_net in ['rnn', 'avr']: w_vec = np.load('data/entity/word_vec.npy') if phrase_net in ['fv', 'fv+cca', 'fv+pca']: if image_net is None: model = PNetFV() elif image_net in ['vgg', 'resnet']: model = IPNetFV(vis_cnn) else: raise RuntimeError elif phrase_net == 'rnn': model = PNetGRU(w_vec) if wo_image else IPNetGRU(vis_cnn, w_vec) elif phrase_net == 'avr': model = PNetAvr(w_vec) if wo_image else IPNetAvr(vis_cnn, w_vec) else: raise NotImplementedError return model
def __init__(self, n_actions): super(CustomModel, self).__init__() with self.init_scope(): self.resNet = L.ResNet50Layers() self.l1 = L.Linear(2138, 1024) self.l2 = L.Linear(1024, 1024) self.l3 = L.Linear(1024, n_actions)
def __init__(self, n_out, lossfunc=0): self.lossfunc = lossfunc initializer = chainer.initializers.HeNormal() super(ResNet, self).__init__() with self.init_scope(): self.base = L.ResNet50Layers() self.l = L.Linear(n_out, initialW=initializer)
def __init__(self, n_bn, n_out, n_out_new): super(NN_ResNet50_bnf, self).__init__() with self.init_scope(): self.resnet50 = L.ResNet50Layers() self.fc = L.Linear(in_size=None, out_size=n_out) self.fc_bn = L.Linear(2048, n_bn) self.fc_out_new = L.Linear(n_bn, n_out_new)
def __init__(self, num_class=10): super(ResNet50Fine, self).__init__() with self.init_scope(): self.base = L.ResNet50Layers() self.fc = L.Linear(None, num_class) self.weight = chainer.Parameter(chainer.initializers.Normal(scale=0.01), (num_class, 2048))
def __init__(self, class_labels): super(ResNet50V1, self).__init__() self.fetch_model() with self.init_scope(): self.base = links.ResNet50Layers() self.fc6 = links.Linear(None, class_labels)
def __init__(self, class_size, loss_weight): super(resnet50, self).__init__() with self.init_scope(): self.model = L.ResNet50Layers(pretrained_model='auto') self.fc6 = L.Linear(2048, class_size) #print(self.model.available_layers) self.loss_weight = cuda.to_gpu(loss_weight) self.class_size = class_size
def get_resnet50(batchsize): model = L.ResNet50Layers(pretrained_model=None) model = Wrapper(model, 'fc6') x = np.random.uniform(size=(batchsize, 3, 224, 224)).astype('f') x = chainer.as_variable(x) t = np.random.randint(size=(batchsize, ), low=0, high=1000).astype(np.int32) t = chainer.as_variable(t) return [x, t], model
def __init__(self, n_actions): super(CustomModel, self).__init__() self.n_actions = n_actions self.history_size = 10 * n_actions with self.init_scope(): self.resNet = L.ResNet50Layers() self.l1 = L.Linear(2048 + self.history_size, 1024) self.l2 = L.Linear(1024, 1024) self.l3 = L.Linear(1024, self.n_actions)
def main(args): # jsonファイルから学習モデルのパラメータを取得する n_out, n_unit, actfun = GET.jsonData(args.param, ['n_out', 'n_unit', 'actfun']) # 学習モデルを生成する model = L.Classifier( CNT(n_out, n_unit, GET.actfun(actfun), base=L.ResNet50Layers(None))) # load_npzのpath情報を取得し、学習済みモデルを読み込む load_path = F.checkModelType(args.model) try: chainer.serializers.load_npz(args.model, model, path=load_path) except: import traceback traceback.print_exc() print(F.fileFuncLine()) exit() # GPUの設定 if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() # else: # model.to_intel64() # 画像の生成 if (args.human_num < 0): h_num = np.random.randint(0, 4) else: h_num = args.human_num if args.image == '': x = create(args.other_path, args.human_path, args.background_path, args.obj_size, args.img_size, args.obj_num, h_num, 1)[0] print(x.shape) elif IMG.isImgPath(args.image): x = cv2.cvtColor(cv2.imread(args.image, IMG.getCh(0)), cv2.COLOR_RGB2BGR) else: print('input image path is not found:', args.image) exit() t = img2resnet(np.array(x)) # 学習モデルを実行する with chainer.using_config('train', False): st = time.time() y = model.predictor(t) num = y[0].data.argmax() print('exec time: {0:.2f}[s]'.format(time.time() - st)) print('result:', num) # 生成結果を保存する name = F.getFilePath(args.out_path, 'predict-' + str(num).zfill(2), '.jpg') print('save:', name) cv2.imwrite(name, x) cv2.imshow(name, x) cv2.waitKey()
def __init__(self, classlabels=66): super(Encoder, self).__init__(model=L.ResNet50Layers(), fc=L.Linear(None, classlabels), model2=PSPNet(pretrained_model='ccp_cfpd_fash'), model_psp_=L.Linear(None, classlabels)) model_psp = self.model2 param_fn = "/home/naka/chainer-pspnet_ver2/all_log/ccp_cfpd_384256_psp50_msgdlr0.01_b12mn/model_epoch-2320" chainer.serializers.load_npz(param_fn, model_psp) self.model_psp_ = model_psp
def __init__(self, **kwargs): super(ResNet50, self).__init__() self.last_ksize = 1 self.last_activation = F.sigmoid npz_model = os.path.join(os.path.dirname(__file__), 'ResNet-50-model.npz') pretrained_model = npz_model if os.path.exists(npz_model) else None with self.init_scope(): self.base = L.ResNet50Layers(pretrained_model) self.addional_layer = AddionalLayer(ch=512)
def setup_extractor(extractor_name): if extractor_name == 'resnet50': extractor = L.ResNet50Layers() elif extractor_name == 'resnet101': extractor = L.ResNet101Layers() elif extractor_name == 'resnet152': extractor = L.ResNet152Layers() else: raise ValueError('Unknown extractor name: {}'.format(extractor_name)) return extractor
def __init__(self, n_out, n_unit=1024, actfun=F.relu, dropout=0.0, base=L.ResNet50Layers(), layer='pool5'): """ [in] n_out: 出力チャンネル """ super(CNT, self).__init__() with self.init_scope(): self.base = base self.l1 = L.Linear(None, n_unit) self.l2 = L.Linear(None, n_unit//2) self.l3 = L.Linear(None, n_unit//4) self.lN = L.Linear(None, n_out) self._actfun = actfun self._dropout_ratio = dropout self._layer = layer
def __init__(self, **kwargs): super(ResNet50, self).__init__() with self.init_scope(): self.base = L.ResNet50Layers() self.fc_1 = L.Linear(None, 1024) self.fc_2 = L.Linear(None, 128 * 128)
def __init__(self, output=8): super(ResNet50_Fine, self).__init__() with self.init_scope(): self.base = L.ResNet50Layers() self.fc = L.Linear(None, output)
def setUp(self): self.model = L.ResNet50Layers(None) self.x = np.zeros((1, 3, 224, 224), dtype=np.float32)
def __init__(self, args, pretrained_model=None): super(Encoder, self).__init__() self.n_resblock = (args.gen_nblock + 1) // 2 # half for Enc and half for Dec self.chs = args.gen_chs if hasattr(args, 'unet'): self.unet = args.unet else: self.unet = 'none' if hasattr(args, 'gen_attention'): self.attention = args.gen_attention else: self.attention = False self.nfc = args.gen_fc if pretrained_model: self.base = pretrained_model self.update_base = False with self.init_scope(): for i in range(args.gen_fc): self.in_c = args.ch self.in_h = args.crop_height self.in_w = args.crop_width # print(args.ch,args.crop_height,args.crop_width) setattr( self, 'l' + str(i), LBR(args.crop_height * args.crop_width * args.ch, activation=args.gen_fc_activation)) ## use pretrained network if hasattr( args, 'gen_pretrained_encoder') and args.gen_pretrained_encoder: self.pretrained = True if "resnet" in args.gen_pretrained_encoder: self.layers = ['conv1'] for i in range(2, args.gen_ndown + 1): self.layers.append('res{}'.format(i)) else: ## VGG16 self.layers = [ 'conv{}_2'.format(i) for i in range(1, min(3, args.gen_ndown + 1)) ] self.layers.extend([ 'conv{}_3'.format(i) for i in range(3, args.gen_ndown + 1) ]) if pretrained_model is None: self.update_base = True if "resnet" in args.gen_pretrained_encoder: self.base = L.ResNet50Layers() else: self.base = L.VGG16Layers() # print(self.chs, self.layers) else: ## new network self.pretrained = False self.c0 = CBR(args.ch, self.chs[0], norm=args.gen_norm, sample=args.gen_sample, activation=args.gen_activation, equalised=args.eqconv) for i in range(1, len(self.chs)): setattr( self, 'd' + str(i), CBR(self.chs[i - 1], self.chs[i], ksize=args.gen_ksize, norm=args.gen_norm, sample=args.gen_down, activation=args.gen_activation, dropout=args.gen_dropout, equalised=args.eqconv, separable=args.spconv)) ## common part if self.unet == 'conv': for i in range(len(self.chs)): setattr( self, 's' + str(i), CBR(self.chs[i], args.skipdim, ksize=3, norm=args.gen_norm, sample='none', equalised=args.eqconv)) for i in range(self.n_resblock): setattr( self, 'r' + str(i), ResBlock(self.chs[-1], norm=args.gen_norm, activation=args.gen_activation, equalised=args.eqconv, separable=args.spconv)) if self.attention: setattr(self, 'a', NonLocalBlock(self.chs[-1])) if hasattr(args, 'latent_dim') and args.latent_dim > 0: self.latent_fc = LBR(args.latent_dim, activation=args.gen_fc_activation)
def __init__(self): super(Encoder, self).__init__(model=L.ResNet50Layers())
def setUp(self): self.model = L.ResNet50Layers(None) self.x = np.random.randn(1, 3, 224, 224).astype(np.float32)
def main(args): # jsonファイルから学習モデルのパラメータを取得する n_out, n_unit, actfun = GET.jsonData(args.param, ['n_out', 'n_unit', 'actfun']) # 学習モデルを生成する model = L.Classifier( CNT(n_out, n_unit, GET.actfun(actfun), base=L.ResNet50Layers(None))) # load_npzのpath情報を取得し、学習済みモデルを読み込む load_path = FNC.checkModelType(args.model) try: chainer.serializers.load_npz(args.model, model, path=load_path) except: import traceback traceback.print_exc() print(FNC.fileFuncLine()) exit() # GPUの設定 if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() xp = cupy else: xp = np # model.to_intel64() # 画像の生成 x = [] t = [] for i in range(n_out): x.extend( create(args.other_path, args.human_path, args.background_path, args.obj_size, args.img_size, args.obj_num, i, args.img_num)) t.extend([i] * args.img_num) x = imgs2resnet(np.array(x), xp) t = xp.array(t, dtype=np.int8) print(x.shape, t.shape) # 学習モデルを実行する with chainer.using_config('train', False): st = time.time() y = model.predictor(x) print('exec time: {0:.2f}[s]'.format(time.time() - st)) # 適合率(precisiton)と再現率(recall)とF値を検証する # precision: 正解の人数を答えたうち、本当に正解の人数だった確率 # (正解が一人の場合に)別の人数を回答すると下がる # recall: 正解の人数に対して、本当に正解の人数を答えられた確率 # (正解が一人でない場合に)一人だと回答すると下がる # F score: 2/((1/recall)+(1/precision)) print('t:', t) print('y:', y.data.argmax(axis=1)) p, r, f, _ = F.classification_summary(y, t) precision = p.data.tolist() recall = r.data.tolist() F_score = f.data.tolist() print('num|precision|recall|F') [ print('{0:3}| {1:4.3f}| {2:4.3f}| {3:4.3f}'.format( i, elem[0], elem[1], elem[2])) for i, elem in enumerate(zip(precision, recall, F_score)) ]
def __init__(self, args, pretrained_model=None, pretrained_off=False): super(Discriminator, self).__init__() self.n_down_layers = args.dis_ndown self.activation = args.dis_activation self.wgan = args.dis_wgan self.chs = args.dis_chs self.attention = args.dis_attention pad = args.dis_ksize // 2 dis_out = 2 if args.dis_reg_weighting > 0 else 1 ## weighted discriminator if pretrained_model: self.base = pretrained_model self.update_base = False with self.init_scope(): if hasattr(args, 'dis_pretrained' ) and args.dis_pretrained and not pretrained_off: self.pretrained = True if "resnet" in args.dis_pretrained: if args.dis_ndown == 1: self.layers = ['conv1'] else: self.layers = ['res{}'.format(args.dis_ndown)] else: ## VGG16 if args.dis_ndown < 3: self.layers = ['conv{}_2'.format(args.dis_ndown)] else: self.layers = ['conv{}_3'.format(args.dis_ndown)] if pretrained_model is None: if "resnet" in args.dis_pretrained: self.base = L.ResNet50Layers() else: self.base = L.VGG16Layers() # print(self.chs, self.layers) else: ## new network self.pretrained = False self.c0 = CBR(None, self.chs[0], ksize=args.dis_ksize, pad=pad, norm='none', sample=args.dis_sample, activation=args.dis_activation, dropout=args.dis_dropout, equalised=args.eqconv, senet=args.senet) #separable=args.spconv) for i in range(1, len(self.chs)): setattr( self, 'c' + str(i), CBR(self.chs[i - 1], self.chs[i], ksize=args.dis_ksize, pad=pad, norm=args.dis_norm, sample=args.dis_down, activation=args.dis_activation, dropout=args.dis_dropout, equalised=args.eqconv, separable=args.spconv, senet=args.senet)) ## common self.csl = CBR(self.chs[-1], 2 * self.chs[-1], ksize=args.dis_ksize, pad=pad, norm=args.dis_norm, sample='none', activation=args.dis_activation, dropout=args.dis_dropout, equalised=args.eqconv, separable=args.spconv, senet=args.senet) if self.attention: setattr(self, 'a', NonLocalBlock(2 * self.chs[-1])) if self.wgan: self.fc1 = LBR(1024, activation='relu') self.fc2 = L.Linear(None, 1) else: self.cl = CBR(2 * self.chs[-1], dis_out, ksize=args.dis_ksize, pad=pad, norm='none', sample='none', activation='none', dropout=False, equalised=args.eqconv, separable=args.spconv, senet=args.senet)
def main(): args = arguments() outdir = os.path.join(args.out, dt.now().strftime('%m%d_%H%M') + "_cgan") # chainer.config.type_check = False chainer.config.autotune = True chainer.config.dtype = dtypes[args.dtype] chainer.print_runtime_info() #print('Chainer version: ', chainer.__version__) #print('GPU availability:', chainer.cuda.available) #print('cuDNN availability:', chainer.cuda.cudnn_enabled) if args.gpu >= 0: chainer.cuda.get_device(args.gpu).use() ## dataset preparation train_d = Dataset(args.train, args.root, args.from_col, args.to_col, clipA=args.clipA, clipB=args.clipB, class_num=args.class_num, crop=(args.crop_height, args.crop_width), imgtype=args.imgtype, random=args.random_translate, grey=args.grey, BtoA=args.btoa) test_d = Dataset(args.val, args.root, args.from_col, args.to_col, clipA=args.clipA, clipB=args.clipB, class_num=args.class_num, crop=(args.crop_height, args.crop_width), imgtype=args.imgtype, random=args.random_translate, grey=args.grey, BtoA=args.btoa) args.crop_height, args.crop_width = train_d.crop if (len(train_d) == 0): print("No images found!") exit() # setup training/validation data iterators train_iter = chainer.iterators.SerialIterator(train_d, args.batch_size) test_iter = chainer.iterators.SerialIterator(test_d, args.nvis, shuffle=False) test_iter_gt = chainer.iterators.SerialIterator( train_d, args.nvis, shuffle=False) ## same as training data; used for validation args.ch = len(train_d[0][0]) args.out_ch = len(train_d[0][1]) print("Input channels {}, Output channels {}".format(args.ch, args.out_ch)) if (len(train_d) * len(test_d) == 0): print("No images found!") exit() ## Set up models # shared pretrained layer if (args.gen_pretrained_encoder and args.gen_pretrained_lr_ratio == 0): if "resnet" in args.gen_pretrained_encoder: pretrained = L.ResNet50Layers() print("Pretrained ResNet model loaded.") else: pretrained = L.VGG16Layers() print("Pretrained VGG model loaded.") if args.gpu >= 0: pretrained.to_gpu() enc_x = net.Encoder(args, pretrained) else: enc_x = net.Encoder(args) # gen = net.Generator(args) dec_y = net.Decoder(args) if args.lambda_dis > 0: dis = net.Discriminator(args) models = {'enc_x': enc_x, 'dec_y': dec_y, 'dis': dis} else: dis = L.Linear(1, 1) models = {'enc_x': enc_x, 'dec_y': dec_y} ## load learnt models optimiser_files = [] if args.model_gen: serializers.load_npz(args.model_gen, enc_x) serializers.load_npz(args.model_gen.replace('enc_x', 'dec_y'), dec_y) print('model loaded: {}, {}'.format( args.model_gen, args.model_gen.replace('enc_x', 'dec_y'))) optimiser_files.append(args.model_gen.replace('enc_x', 'opt_enc_x')) optimiser_files.append(args.model_gen.replace('enc_x', 'opt_dec_y')) if args.model_dis: serializers.load_npz(args.model_dis, dis) print('model loaded: {}'.format(args.model_dis)) optimiser_files.append(args.model_dis.replace('dis', 'opt_dis')) ## send models to GPU if args.gpu >= 0: enc_x.to_gpu() dec_y.to_gpu() dis.to_gpu() # Setup optimisers def make_optimizer(model, lr, opttype='Adam', pretrained_lr_ratio=1.0): # eps = 1e-5 if args.dtype==np.float16 else 1e-8 optimizer = optim[opttype](lr) optimizer.setup(model) if args.weight_decay > 0: if opttype in ['Adam', 'AdaBound', 'Eve']: optimizer.weight_decay_rate = args.weight_decay else: if args.weight_decay_norm == 'l2': optimizer.add_hook( chainer.optimizer.WeightDecay(args.weight_decay)) else: optimizer.add_hook( chainer.optimizer_hooks.Lasso(args.weight_decay)) return optimizer opt_enc_x = make_optimizer(enc_x, args.learning_rate_gen, args.optimizer) opt_dec_y = make_optimizer(dec_y, args.learning_rate_gen, args.optimizer) opt_dis = make_optimizer(dis, args.learning_rate_dis, args.optimizer) optimizers = {'enc_x': opt_enc_x, 'dec_y': opt_dec_y, 'dis': opt_dis} ## resume optimisers from file if args.load_optimizer: for (m, e) in zip(optimiser_files, optimizers): if m: try: serializers.load_npz(m, optimizers[e]) print('optimiser loaded: {}'.format(m)) except: print("couldn't load {}".format(m)) pass # finetuning if args.gen_pretrained_encoder: if args.gen_pretrained_lr_ratio == 0: enc_x.base.disable_update() else: for func_name in enc_x.encoder.base._children: for param in enc_x.encoder.base[func_name].params(): param.update_rule.hyperparam.eta *= args.gen_pretrained_lr_ratio # Set up trainer updater = Updater( models=(enc_x, dec_y, dis), iterator={'main': train_iter}, optimizer=optimizers, # converter=convert.ConcatWithAsyncTransfer(), params={'args': args}, device=args.gpu) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=outdir) ## save learnt results at a specified interval or at the end of training if args.snapinterval < 0: args.snapinterval = args.epoch snapshot_interval = (args.snapinterval, 'epoch') display_interval = (args.display_interval, 'iteration') for e in models: trainer.extend(extensions.snapshot_object(models[e], e + '{.updater.epoch}.npz'), trigger=snapshot_interval) if args.parameter_statistics: trainer.extend(extensions.ParameterStatistics( models[e])) ## very slow for e in optimizers: trainer.extend(extensions.snapshot_object( optimizers[e], 'opt_' + e + '{.updater.epoch}.npz'), trigger=snapshot_interval) ## plot NN graph if args.lambda_rec_l1 > 0: trainer.extend( extensions.dump_graph('dec_y/loss_L1', out_name='enc.dot')) elif args.lambda_rec_l2 > 0: trainer.extend( extensions.dump_graph('dec_y/loss_L2', out_name='gen.dot')) elif args.lambda_rec_ce > 0: trainer.extend( extensions.dump_graph('dec_y/loss_CE', out_name='gen.dot')) if args.lambda_dis > 0: trainer.extend( extensions.dump_graph('dis/loss_real', out_name='dis.dot')) ## log outputs log_keys = ['epoch', 'iteration', 'lr'] log_keys_gen = ['myval/loss_L1', 'myval/loss_L2'] log_keys_dis = [] if args.lambda_rec_l1 > 0: log_keys_gen.append('dec_y/loss_L1') if args.lambda_rec_l2 > 0: log_keys_gen.append('dec_y/loss_L2') if args.lambda_rec_ce > 0: log_keys_gen.extend(['dec_y/loss_CE', 'myval/loss_CE']) if args.lambda_reg > 0: log_keys.extend(['enc_x/loss_reg']) if args.lambda_tv > 0: log_keys_gen.append('dec_y/loss_tv') if args.lambda_dis > 0: log_keys_dis.extend( ['dec_y/loss_dis', 'dis/loss_real', 'dis/loss_fake']) if args.lambda_mispair > 0: log_keys_dis.append('dis/loss_mispair') if args.dis_wgan: log_keys_dis.extend(['dis/loss_gp']) trainer.extend(extensions.LogReport(trigger=display_interval)) trainer.extend(extensions.PrintReport(log_keys + log_keys_gen + log_keys_dis), trigger=display_interval) if extensions.PlotReport.available(): # trainer.extend(extensions.PlotReport(['lr'], 'iteration',trigger=display_interval, file_name='lr.png')) trainer.extend( extensions.PlotReport(log_keys_gen, 'iteration', trigger=display_interval, file_name='loss_gen.png', postprocess=plot_log)) trainer.extend( extensions.PlotReport(log_keys_dis, 'iteration', trigger=display_interval, file_name='loss_dis.png')) trainer.extend(extensions.ProgressBar(update_interval=10)) # learning rate scheduling trainer.extend(extensions.observe_lr(optimizer_name='enc_x'), trigger=display_interval) if args.optimizer in ['Adam', 'AdaBound', 'Eve']: lr_target = 'eta' else: lr_target = 'lr' if args.lr_drop > 0: ## cosine annealing for e in [opt_enc_x, opt_dec_y, opt_dis]: trainer.extend(CosineShift(lr_target, args.epoch // args.lr_drop, optimizer=e), trigger=(1, 'epoch')) else: for e in [opt_enc_x, opt_dec_y, opt_dis]: #trainer.extend(extensions.LinearShift('eta', (1.0,0.0), (decay_start_iter,decay_end_iter), optimizer=e)) trainer.extend(extensions.ExponentialShift('lr', 0.33, optimizer=e), trigger=(args.epoch // args.lr_drop, 'epoch')) # evaluation vis_folder = os.path.join(outdir, "vis") os.makedirs(vis_folder, exist_ok=True) if not args.vis_freq: args.vis_freq = max(len(train_d) // 2, 50) trainer.extend(VisEvaluator({ "test": test_iter, "train": test_iter_gt }, { "enc_x": enc_x, "dec_y": dec_y }, params={ 'vis_out': vis_folder, 'args': args }, device=args.gpu), trigger=(args.vis_freq, 'iteration')) # ChainerUI: removed until ChainerUI updates to be compatible with Chainer 6.0 trainer.extend(CommandsExtension()) # Run the training print("\nresults are saved under: ", outdir) save_args(args, outdir) trainer.run()
def __init__(self, n_out): super(NN_ResNet50, self).__init__() with self.init_scope(): self.resnet50 = L.ResNet50Layers() self.fc = L.Linear(in_size=None, out_size=n_out)
iterator = chainer.iterators.MultithreadIterator(dataset, args.batch_size, n_threads=3, repeat=False, shuffle=False) # iterator = chainer.iterators.SerialIterator(dataset, args.batch_size,repeat=False, shuffle=False) if args.ch != len(dataset[0][0]): print("number of input channels is different during training.") print("Input channels {}, Output channels {}".format(args.ch, args.out_ch)) ## load generator models if "enc" in args.model_gen: if (args.gen_pretrained_encoder and args.gen_pretrained_lr_ratio == 0): if "resnet" in args.gen_pretrained_encoder: pretrained = L.ResNet50Layers() print("Pretrained ResNet model loaded.") else: pretrained = L.VGG16Layers() print("Pretrained VGG model loaded.") if args.gpu >= 0: pretrained.to_gpu() enc = net.Encoder(args, pretrained) else: enc = net.Encoder(args) print('Loading {:s}..'.format(args.model_gen)) serializers.load_npz(args.model_gen, enc) dec = net.Decoder(args) modelfn = args.model_gen.replace('enc_x', 'dec_y') modelfn = modelfn.replace('enc_y', 'dec_x') print('Loading {:s}..'.format(modelfn))
def main(): model = L.VGG16Layers() save_as_onnx_then_import_from_mxnet(model, 'vgg16.onnx') model = L.ResNet50Layers() save_as_onnx_then_import_from_mxnet(model, 'resnet50.onnx')