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)