def main():
iBatchSize = 10
iEpoch = 10
ndX, ndY = create_data()
# type:ArrayDataset
adDataset = gdata.ArrayDataset(ndX, ndY)
# type:DataLoader
dlDataIter = gdata.DataLoader(adDataset, batch_size=iBatchSize,
shuffle=True)
net = create_net()
net.initialize(init.Normal(sigma=0.01))
loss = gloss.L2Loss()
trainer = Trainer(net.collect_params(), "sgd", {"learning_rate": 0.01})
for iIndex in range(iEpoch):
for ndBatchX, ndBatchY in dlDataIter:
with autograd.record():
l = loss(net(ndBatchX), ndBatchY)
l.backward()
trainer.step(iBatchSize)
l = loss(net(ndX), ndY)
print("[Log] Epoch:%d Loss:%f" % (iIndex, l.mean().asnumpy()))
print(net[0].weight.data())
print(net[0].bias.data())
class MLPEstimator(TrainableEstimator):
def __init__(
self,
input_shape: Sequence[int],
hidden_dims: Sequence[int],
hidden_activation: Optional[str],
lr: float,
):
input_dim, = input_shape # must be 1D
self.model = make_mlp(input_dim, hidden_dims, 1, hidden_activation)
self.model.initialize()
self.trainer = Trainer(self.model.collect_params(),
mx.optimizer.Adam(lr))
self.loss_fn = loss.L2Loss()
def batch_estimate(self, data: np.ndarray) -> np.ndarray:
tensor = mx.nd.array(data)
result = self.model(tensor)
return result.asnumpy()
def batch_estimate_and_update(self, data: np.ndarray,
targets: np.ndarray) -> np.ndarray:
input_tensor = mx.nd.array(data)
target_tensor = mx.nd.array(targets)
with mx.autograd.record():
result = self.model(input_tensor)
loss = self.loss_fn(result, target_tensor)
loss.backward()
self.trainer.step(input_tensor.shape[0])
return result.asnumpy()
def train(model, features, X, X_train, y_train, epochs):
cross_entropy = SigmoidBinaryCrossEntropyLoss(from_sigmoid=True)
trainer = Trainer(model.collect_params(), 'sgd', {
'learning_rate': 0.001,
'momentum': 1
})
feature_representations = [features(X).asnumpy()]
for e in range(1, epochs + 1):
cum_loss = 0
cum_preds = []
for i, x in enumerate(X_train.flatten()):
y = array(y_train)[i]
with autograd.record():
preds = model(X)[x]
loss = cross_entropy(preds, y)
# logger.debug("x:[{}], y:[{}], pred:[{}], loss:[{}]".format(x,y,preds,loss.asscalar()))
loss.backward()
trainer.step(1)
cum_loss += loss.asscalar()
cum_preds += [preds.asscalar()]
feature_representations.append(features(X).asnumpy())
if (e % (epochs // 10)) == 0:
logger.debug(f"Epoch {e}/{epochs} -- Loss: {cum_loss: f}")
logger.debug(cum_preds)
return feature_representations
def get_Eout(T, M, lr):
net = nn.Sequential()
net.add(nn.Dense(M, activation='tanh'))
net.add(nn.Dense(1, activation='tanh'))
net.initialize(init.Normal(sigma=0.01))
trainer = Trainer(net.collect_params(), 'sgd', {'learning_rate': lr})
loss = gloss.L2Loss()
for t in range(T):
if t % 1000 == 0:
print('t:', t)
for X, y in train_iter:
with autograd.record():
l = loss(net(X), y)
l.backward()
trainer.step(batch_size)
l = loss(net(X), y)
print('训练完成,开始检验')
for tX, ty in test_iter:
l = loss(net(tX), ty).mean().asscalar()
print('Eout;', l)
return l, M
def fit(nn: nn.Block, xs, ys, batchsize=20, draw_pars=None, drfunc=None):
"""训练函数"""
ds = mxdata.ArrayDataset(xs, ys)
dl = mxdata.DataLoader(ds, batch_size=batchsize, shuffle=True)
###
tr = Trainer(nn.collect_params(),
optimizer="rmsprop",
optimizer_params={"learning_rate": 0.001})
###
lfunc = loss.L2Loss()
for i in range(2000):
for data, label in dl:
with ag.record():
y = nn(data)
ls = lfunc(y, label).mean() #type:nd.NDArray
ls.backward()
tr.step(batch_size=batchsize, ignore_stale_grad=True)
print(f"Loss值:{ls.asscalar()}")
# if ls.asscalar()<0.1:
# break
# 绘图
if draw_pars is not None and drfunc is not None and ls.asscalar() < 10:
plt.ion()
plt.gcf().clear()
drfunc(draw_pars[4], nn, draw_pars[0], draw_pars[1], draw_pars[2],
draw_pars[3])
plt.pause(0.5)
def main():
tensorboard_writer = TensorboardStatsWriter(save_path='save/logs')
console_writer = ConsoleStatsWriter(save_path='save/console')
game = gym.make('Acrobot-v1')
game._max_episode_steps = 2.5e3
agent = GymAdapter(
PolicyGradAgent(observation_space=game.observation_space,
action_space=game.action_space,
reward_range=game.reward_range,
entropy_weight=5e-3,
discount=0.995))
agent.initialize(init.Xavier())
with agent, tensorboard_writer, console_writer:
rollout = play(game, agent, render=True, blur_weight=0.99)
eps = episodes(rollout)
trainer = Trainer(agent.collect_params(), 'adam',
dict(learning_rate=5e-3))
for obs, acts, rews, infos in eps:
with autograd.record():
loss, stats = agent.loss(obs, acts, rews, infos)
loss.backward()
trainer.step(len(obs))
console_writer.write(stats)
tensorboard_writer.write(stats)
def __init__(self,
model_param,
vocab_path,
mode='train',
vocab_tag_path=None,
encoder_type='rnn',
head_attention=False,
decoder_cell='lstm',
ctx=cpu()):
"""
# TODO 选择模型的编码器解码器部分
# TODO Encoder: Parsed | RNN
# TODO Decoder: Headline | RNN
# TODO Decoder_RNN_TYPE: DLSTM | LSMT | GRU
根据参数与模式，构建模型
:param mode: train|decode|test 控制当前模型的用途
:param vocab_path: 词典路径
:param vocab_tag_path: 句法解析标记词典路径
:param model_param: 模型中的超参数
"""
self.vocab_path = vocab_path
self.vocab = Vocab(vocab_path)
if vocab_tag_path is not None:
self.vocab_tag_path = vocab_tag_path
self.vocab_tag = Vocab(vocab_tag_path)
self.mode = mode
self.loss = SoftmaxCrossEntropyLoss()
self.model_param = model_param
self.encoder_type = encoder_type
if encoder_type == 'rnn':
pass
# self.model = Seq2SeqRNN(self.vocab, self.model_param, ctx)
self.model = Seq2SeqRNN(self.vocab,
'LSTM',
model_param['emb_size'],
model_param['hidden_size'],
self.vocab.size,
60,
'Bahdanau',
'two_way',
None,
None,
0,
1,
ctx=ctx)
elif encoder_type == 'parse':
self.model = ParseModel(self.vocab, self.vocab_tag,
self.model_param, ctx)
self.model.initialize(ctx=ctx)
self.ctx = ctx
self.trainer = Trainer(self.model.collect_params(), 'adam',
{'learning_rate': 0.01})
self.global_step = 0
self.sw = SummaryWriter('./logs', flush_secs=2)
def __init__(self, net, ctx):
self.net = net
self.ctx = ctx
self.trainer = Trainer(net.collect_params(), 'adam',
{'learning_rate': 0.01})
self.loss_fun = None
self.metric = None
self.history = plot_history.TrainingHistory(['acc'])
def model_compile(self):
# 编译模型
self.loss = gloss.SoftmaxCrossEntropyLoss(axis=1)
lr_sch = lr_scheduler.FactorScheduler(step=100, factor=0.9)
optimizer_params = {
'learning_rate': self.learning_rate,
'lr_scheduler': lr_sch
}
self.trainer = Trainer(self.model.collect_params(),
optimizer='adam',
optimizer_params=optimizer_params)
def load_trainer(self):
gluon.model_zoo.vision.ResNetV2
opt = self.cfg.optimizer
opt_dict = {"learning_rate": self.cfg.learning_rate}
if self.cfg.momentum is not None:
opt_dict["momentum"] = self.cfg.momentum
if self.cfg.weight_decay is not None:
opt_dict["wd"] = self.cfg.weight_decay
if self.trainer is None:
self.trainer = Trainer(self.net.collect_params(), opt, opt_dict)
else:
self.trainer._init_optimizer(opt, opt_dict)
class Network:
def __init__(self, net: nn.HybridBlock, cfg: Config, transform):
self.net = net
self.cfg = cfg
self.transform = transform
self.loss = cfg.loss
self.trainer = None
self.load_params() # Load the current best params
self.load_trainer()
def predict(self, cur: Board, goal: Board) -> int:
state = nd.array([self.transform(cur)], ctx=self.cfg.context)
return round(self.net(state)[0].asscalar())
def load_trainer(self):
gluon.model_zoo.vision.ResNetV2
opt = self.cfg.optimizer
opt_dict = {"learning_rate": self.cfg.learning_rate}
if self.cfg.momentum is not None:
opt_dict["momentum"] = self.cfg.momentum
if self.cfg.weight_decay is not None:
opt_dict["wd"] = self.cfg.weight_decay
if self.trainer is None:
self.trainer = Trainer(self.net.collect_params(), opt, opt_dict)
else:
self.trainer._init_optimizer(opt, opt_dict)
def load_params(self, round=None):
params_file = self.params_file(round)
if os.path.exists(params_file):
self.net.load_parameters(params_file, ctx=self.cfg.context)
else:
print("Params file not found. Initializing...")
self.net.initialize(init=init.Xavier(), ctx=self.cfg.context)
self.save_params()
def save_params(self, round=None):
self.net.save_parameters(self.params_file(round))
def export_model(self):
export_file = f"{self.cfg.model_base}-symbol.params"
self.net.hybridize()
self.predict(Board.ordered(),
Board.ordered()) # predict an null example to init
self.net.export(self.cfg.model_base, 9999) # ugly workaround
os.replace(self.params_file(9999), export_file)
def params_file(self, round=None):
if round is None: # Load the best params
return f"{self.cfg.model_base}.params"
else:
return f"{self.cfg.model_base}-{round:04d}.params"
def train(self,
source_path,
target_path,
lda_path,
batch_size=16,
epoch_num=15,
optimizer='adam',
learning_rate=0.01):
"""
根据定义好的模型，训练模型
:param epoch_num: 训练迭代数据轮次
:param optimizer: 优化器，或者是优化器名字str
:param learning_rate: 学习率
:return:
"""
source_list, target_list = os.listdir(source_path), os.listdir(
target_path)
if len(source_list) != len(target_list):
raise ValueError('source and target file not match')
data_size = len(source_list)
del source_list
del target_list
if self.encoder_type == 'parse':
print('single-pass mode in parse encoder')
batch_size = 1
trainer = Trainer(self.model.collect_params(), optimizer,
{'learning_rate': learning_rate})
print('Reading data...')
data = self._data_generator_one_batch(source_path, target_path,
lda_path)
best_score = 9999
for epoch in range(epoch_num):
loss_sum = 0.0
with tqdm(total=len(data)) as pbar:
for x, y, lda in data:
with autograd.record():
logits = self.model(x, y, lda)
loss = self.sequence_loss(logits, y)
loss.backward()
trainer.step(1)
loss_sum += loss.asscalar()
pbar.update(1)
self.global_step += 1
loss_mean = loss_sum / len(data)
print('epoch {}, loss:{}'.format(epoch, loss_mean))
if loss_mean < best_score:
self.model.collect_params().save('best.model')
def __init__(
self,
input_shape: Sequence[int],
hidden_dims: Sequence[int],
hidden_activation: Optional[str],
lr: float,
):
input_dim, = input_shape # must be 1D
self.model = make_mlp(input_dim, hidden_dims, 1, hidden_activation)
self.model.initialize()
self.trainer = Trainer(self.model.collect_params(),
mx.optimizer.Adam(lr))
self.loss_fn = loss.L2Loss()
def _define_optimizers(self):
self.trainerG = Trainer(self.netG.collect_params(),
optimizer='adam',
optimizer_params={
'learning_rate': self.opt.lr,
'beta1': self.opt.beta1,
'beta2': self.opt.beta2
})
self.trainerD = Trainer(self.netD.collect_params(),
optimizer='adam',
optimizer_params={
'learning_rate': self.opt.lr,
'beta1': self.opt.beta1,
'beta2': self.opt.beta2
})
def gluon_random_data_run():
mlflow.gluon.autolog()
with mlflow.start_run() as run:
data = DataLoader(LogsDataset(), batch_size=128, last_batch="discard")
validation = DataLoader(LogsDataset(),
batch_size=128,
last_batch="discard")
model = HybridSequential()
model.add(Dense(64, activation="relu"))
model.add(Dense(64, activation="relu"))
model.add(Dense(10))
model.initialize()
model.hybridize()
trainer = Trainer(model.collect_params(),
"adam",
optimizer_params={
"learning_rate": .001,
"epsilon": 1e-07
})
est = estimator.Estimator(net=model,
loss=SoftmaxCrossEntropyLoss(),
metrics=Accuracy(),
trainer=trainer)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
est.fit(data, epochs=3, val_data=validation)
return client.get_run(run.info.run_id)
def get_gluon_random_data_run(log_models=True):
mlflow.gluon.autolog(log_models)
with mlflow.start_run() as run:
data = DataLoader(LogsDataset(), batch_size=128, last_batch="discard")
validation = DataLoader(LogsDataset(),
batch_size=128,
last_batch="discard")
model = HybridSequential()
model.add(Dense(64, activation="relu"))
model.add(Dense(64, activation="relu"))
model.add(Dense(10))
model.initialize()
model.hybridize()
trainer = Trainer(
model.collect_params(),
"adam",
optimizer_params={
"learning_rate": 0.001,
"epsilon": 1e-07
},
)
est = get_estimator(model, trainer)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
est.fit(data, epochs=3, val_data=validation)
client = mlflow.tracking.MlflowClient()
return client.get_run(run.info.run_id)
def test_autolog_registering_model():
registered_model_name = "test_autolog_registered_model"
mlflow.gluon.autolog(registered_model_name=registered_model_name)
data = DataLoader(LogsDataset(), batch_size=128, last_batch="discard")
model = HybridSequential()
model.add(Dense(64, activation="relu"))
model.add(Dense(10))
model.initialize()
model.hybridize()
trainer = Trainer(model.collect_params(),
"adam",
optimizer_params={
"learning_rate": 0.001,
"epsilon": 1e-07
})
est = get_estimator(model, trainer)
with mlflow.start_run(), warnings.catch_warnings():
warnings.simplefilter("ignore")
est.fit(data, epochs=3)
registered_model = MlflowClient().get_registered_model(
registered_model_name)
assert registered_model.name == registered_model_name
def test_autolog_persists_manually_created_run():
kiwi.gluon.autolog()
data = DataLoader(LogsDataset(), batch_size=128, last_batch="discard")
with kiwi.start_run() as run:
model = HybridSequential()
model.add(Dense(64, activation="relu"))
model.add(Dense(64, activation="relu"))
model.add(Dense(10))
model.initialize()
model.hybridize()
trainer = Trainer(model.collect_params(),
"adam",
optimizer_params={
"learning_rate": .001,
"epsilon": 1e-07
})
est = estimator.Estimator(net=model,
loss=SoftmaxCrossEntropyLoss(),
metrics=Accuracy(),
trainer=trainer)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
est.fit(data, epochs=3)
assert kiwi.active_run().info.run_id == run.info.run_id
def __init__(self, input_channels) -> None:
self._lossfun = Lossfun(alpha=1, beta_vgg=100, beta_pix=1)
self._network = Network(3, input_channels)
self._trainer = Trainer(self._network.collect_params(), "adam", {
"beta1": 0.5,
"learning_rate": 0.0002
})
def test_autolog_persists_manually_created_run():
mlflow.gluon.autolog()
data = DataLoader(LogsDataset(), batch_size=128, last_batch="discard")
with mlflow.start_run() as run:
model = HybridSequential()
model.add(Dense(64, activation="relu"))
model.add(Dense(64, activation="relu"))
model.add(Dense(10))
model.initialize()
model.hybridize()
trainer = Trainer(
model.collect_params(),
"adam",
optimizer_params={
"learning_rate": 0.001,
"epsilon": 1e-07
},
)
est = get_estimator(model, trainer)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
est.fit(data, epochs=3)
assert mlflow.active_run().info.run_id == run.info.run_id
def test_autolog_ends_auto_created_run():
mlflow.gluon.autolog()
data = DataLoader(LogsDataset(), batch_size=128, last_batch="discard")
model = HybridSequential()
model.add(Dense(64, activation="relu"))
model.add(Dense(64, activation="relu"))
model.add(Dense(10))
model.initialize()
model.hybridize()
trainer = Trainer(model.collect_params(),
"adam",
optimizer_params={
"learning_rate": 0.001,
"epsilon": 1e-07
})
est = estimator.Estimator(net=model,
loss=SoftmaxCrossEntropyLoss(),
trainer=trainer,
**get_metrics())
with warnings.catch_warnings():
warnings.simplefilter("ignore")
est.fit(data, epochs=3)
assert mlflow.active_run() is None
def gluon_model(model_data):
train_data, train_label, _ = model_data
train_data_loader = DataLoader(list(zip(train_data, train_label)),
batch_size=128,
last_batch="discard")
model = HybridSequential()
model.add(Dense(128, activation="relu"))
model.add(Dense(64, activation="relu"))
model.add(Dense(10))
model.initialize()
model.hybridize()
trainer = Trainer(model.collect_params(),
"adam",
optimizer_params={
"learning_rate": 0.001,
"epsilon": 1e-07
})
# `metrics` was renamed in mxnet 1.6.0: https://github.com/apache/incubator-mxnet/pull/17048
arg_name = ("metrics"
if LooseVersion(mx.__version__) < LooseVersion("1.6.0") else
"train_metrics")
est = estimator.Estimator(net=model,
loss=SoftmaxCrossEntropyLoss(),
trainer=trainer,
**{arg_name: Accuracy()})
with warnings.catch_warnings():
warnings.simplefilter("ignore")
est.fit(train_data_loader, epochs=3)
return model
def gluon_model(model_data):
train_data, train_label, _ = model_data
train_data_loader = DataLoader(list(zip(train_data, train_label)),
batch_size=128,
last_batch="discard")
model = HybridSequential()
model.add(Dense(128, activation="relu"))
model.add(Dense(64, activation="relu"))
model.add(Dense(10))
model.initialize()
model.hybridize()
trainer = Trainer(model.collect_params(),
"adam",
optimizer_params={
"learning_rate": .001,
"epsilon": 1e-07
})
est = estimator.Estimator(net=model,
loss=SoftmaxCrossEntropyLoss(),
metrics=Accuracy(),
trainer=trainer)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
est.fit(train_data_loader, epochs=3)
return model
def set_trainer(opts, net):
"""Setup training policy"""
return Trainer(net.collect_params(),
optimizer=opts.optimizer,
optimizer_params={
'learning_rate': opts.base_lr,
'wd': opts.wd
})
def trainer(self, net):
print("trainer \t optim:sgd wd: 1e-4, momentum:0.9")
return Trainer(net.collect_params(),
optimizer="sgd",
optimizer_params={
"wd": 1e-4,
"momentum": 0.9
})
def train(net_G, net_D, dataloader, opt):
'''
Entry of Training process
:return:
'''
sw = SummaryWriter(logdir='./logs', flush_secs=5)
print("Random Seed: ", opt.manualSeed)
random.seed(opt.manualSeed)
mx.random.seed(opt.manualSeed)
ctx = try_gpu()
print("ctx: ", ctx)
# initialize netG, netD
net_G, net_D = init_networks(net_G, net_D, opt, ctx)
# optimizer settings
trainer_G = Trainer(net_G.collect_params(),
optimizer='adam',
optimizer_params={
'learning_rate': opt.lrG,
'beta1': opt.beta1,
'beta2': 0.999
})
trainer_D = Trainer(net_D.collect_params(),
optimizer='adam',
optimizer_params={
'learning_rate': opt.lrD,
'beta1': opt.beta1,
'beta2': 0.999
})
loss_f = loss.SigmoidBinaryCrossEntropyLoss()
print("Start training ...")
for epoch in range(opt.num_epochs):
train_step(dataloader, net_G, net_D, trainer_G, trainer_D, loss_f, opt,
ctx, sw, epoch)
# do checkpointing
net_G.save_parameters('{0}/netG_epoch_{1}.param'.format(
opt.experiment, epoch))
net_D.save_parameters('{0}/netD_epoch_{1}.param'.format(
opt.experiment, epoch))
def __init__(self, input_channels) -> None:
self._history = History(50)
self._lossfun = Lossfun(1)
self._network = Network(1, input_channels + 18)
self._trainer = Trainer(self._network.collect_params(), "adam", {
"beta1": 0.5,
"learning_rate": 0.0002
})
def get_tf_from_Model(name:str,model:IModel,custom_params:ParameterDict,learning_rate=0.01,optimizer="rmsprop",wd=0,clip=0,testiters=3,loadfile=False):
optp={"learning_rate":learning_rate}
if wd>0:
optp["wd"]=wd
if clip>0:
optp["clip_gradient"]=clip
tr=Trainer(custom_params,"rmsprop",optimizer_params=optp)
tf=TrainInfo(model,tr,print_period=100,modname=name,keep_stale=True,test_iter=testiters,train_count_on_batch=1,show_traininfo=True,loadfile=loadfile)
return tf
def trainer(self, net):
wd, mom = 1e-4, 0.9
print("trainer \t optim:sgd wd: %f, momentum: %f" % (wd, mom))
return Trainer(net.collect_params(),
optimizer="sgd",
optimizer_params={
"wd": wd,
"momentum": mom
})
def train(data_dir, pretrain_model, epoches=3, lr=0.001, wd=5e-4, momentum=0.9, batch_size=5, ctx=mx.cpu(), verbose_step=2, ckpt='ckpt'):
icdar_loader = ICDAR(data_dir=data_dir)
loader = DataLoader(icdar_loader, batch_size=batch_size, shuffle=True)
net = PSENet(num_kernels=7, ctx=ctx)
# initial params
net.collect_params().initialize(mx.init.Normal(sigma=0.01), ctx=ctx)
# net.initialize(ctx=ctx)
# net.load_parameters(pretrain_model, ctx=ctx, allow_missing=True, ignore_extra=True)
pse_loss = DiceLoss(lam=0.7)
cos_shc = ls.PolyScheduler(max_update=icdar_loader.length * epoches//batch_size, base_lr=lr)
trainer = Trainer(
net.collect_params(),
'sgd',
{
'learning_rate': lr,
'wd': wd,
'momentum': momentum,
'lr_scheduler':cos_shc
})
summary_writer = SummaryWriter(ckpt)
for e in range(epoches):
cumulative_loss = 0
for i, item in enumerate(loader):
im, score_maps, kernels, training_masks, ori_img = item
im = im.as_in_context(ctx)
score_maps = score_maps[:, ::4, ::4].as_in_context(ctx)
kernels = kernels[:, ::4, ::4, :].as_in_context(ctx)
training_masks = training_masks[:, ::4, ::4].as_in_context(ctx)
with autograd.record():
kernels_pred = net(im)
loss = pse_loss(score_maps, kernels, kernels_pred, training_masks)
loss.backward()
trainer.step(batch_size)
if i%verbose_step==0:
global_steps = icdar_loader.length * e + i * batch_size
summary_writer.add_image('score_map', score_maps[0:1, :, :], global_steps)
summary_writer.add_image('score_map_pred', kernels_pred[0:1, -1, :, :], global_steps)
summary_writer.add_image('kernel_map', kernels[0:1, :, :, 0], global_steps)
summary_writer.add_image('kernel_map_pred', kernels_pred[0:1, 0, :, :], global_steps)
summary_writer.add_scalar('loss', mx.nd.mean(loss).asscalar(), global_steps)
summary_writer.add_scalar('c_loss', mx.nd.mean(pse_loss.C_loss).asscalar(), global_steps)
summary_writer.add_scalar('kernel_loss', mx.nd.mean(pse_loss.kernel_loss).asscalar(), global_steps)
summary_writer.add_scalar('pixel_accuracy', pse_loss.pixel_acc, global_steps)
print("step: {}, loss: {}, score_loss: {}, kernel_loss: {}, pixel_acc: {}".format(i * batch_size, mx.nd.mean(loss).asscalar(), \
mx.nd.mean(pse_loss.C_loss).asscalar(), mx.nd.mean(pse_loss.kernel_loss).asscalar(), \
pse_loss.pixel_acc))
cumulative_loss += mx.nd.mean(loss).asscalar()
print("Epoch {}, loss: {}".format(e, cumulative_loss))
net.save_parameters(os.path.join(ckpt, 'model_{}.param'.format(e)))
summary_writer.close()
netD = DCGAN_D(opt.imageSize, nz, nc, ndf, ngpu, n_extra_layers)
netD.initialize(mx.init.Xavier(factor_type='in',magnitude=0.01), ctx=context)
weights_init(netD.main)
if opt.netD != '':
netD.load_parameters(opt.netD)
print(netD)
input = mx.nd.zeros((opt.batchSize, 3, opt.imageSize, opt.imageSize))
noise = mx.nd.zeros((opt.batchSize, nz, 1, 1))
fixed_noise = mx.ndarray.random.normal(shape=(opt.batchSize, nz, 1, 1))
one = mx.nd.array([1])
mone = one * -1
# setup optimizer
if opt.adam:
trainerD = Trainer(netD.collect_params(),optimizer='adam',optimizer_params={'learning_rate': opt.lrD,'beta1': opt.beta1,'beta2':0.999})
trainerG = Trainer(netG.collect_params(),optimizer='adam',optimizer_params={'learning_rate': opt.lrG, 'beta1': opt.beta1, 'beta2': 0.999})
else:
trainerD = Trainer(netD.collect_params(),optimizer='rmsprop',optimizer_params={'learning_rate': opt.lrD,'gamma1':0.99,'gamma2':0.99,'epsilon':1e-12})
trainerG = Trainer(netG.collect_params(),optimizer='rmsprop', optimizer_params={'learning_rate': opt.lrG,'gamma1':0.99,'gamma2':0.99,'epsilon':1e-14})
print('start training')
sw = SummaryWriter(logdir='./logs', flush_secs=5)
netD.hybridize()
netG.hybridize()
gen_iterations = 0
for epoch in range(opt.niter):
data_iter = iter(dataloader)
