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')
