def train(use_cuda, train_program, params_dirname): place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() word_dict = paddle.dataset.imdb.word_dict() trainer = fluid.Trainer( train_func=partial(train_program, word_dict), place=place, optimizer_func=optimizer_func) def event_handler(event): if isinstance(event, fluid.EndEpochEvent): test_reader = paddle.batch( paddle.dataset.imdb.test(word_dict), batch_size=BATCH_SIZE) avg_cost, acc = trainer.test( reader=test_reader, feed_order=['words', 'label']) print("avg_cost: %s" % avg_cost) print("acc : %s" % acc) if acc > 0.2: # Smaller value to increase CI speed trainer.save_params(params_dirname) trainer.stop() else: print('BatchID {0}, Test Loss {1:0.2}, Acc {2:0.2}'.format( event.epoch + 1, avg_cost, acc)) if math.isnan(avg_cost): sys.exit("got NaN loss, training failed.") elif isinstance(event, fluid.EndStepEvent): print("Step {0}, Epoch {1} Metrics {2}".format( event.step, event.epoch, map(np.array, event.metrics))) if event.step == 1: # Run 2 iterations to speed CI trainer.save_params(params_dirname) trainer.stop() train_reader = paddle.batch( paddle.reader.shuffle( paddle.dataset.imdb.train(word_dict), buf_size=25000), batch_size=BATCH_SIZE) trainer.train( num_epochs=1, event_handler=event_handler, reader=train_reader, feed_order=['words', 'label'])
def train(use_cuda, train_program, params_dirname): #批处理大小 BATCH_SIZE = 128 #训练轮数 EPOCH_NUM = 10 train_reader = paddle.batch(paddle.reader.shuffle( paddle.dataset.cifar.train10(), buf_size=50000), batch_size=BATCH_SIZE) test_reader = paddle.batch(paddle.dataset.cifar.test10(), batch_size=BATCH_SIZE) def event_handler(event): if isinstance(event, fluid.EndStepEvent): #每训练100个批次打印一次状态 if event.step % 100 == 0: print("\nStep %d, Epoch %d, Cost %f, Acc %f" % (event.step, event.epoch, event.metrics[0], event.metrics[1])) else: sys.stdout.write('.') sys.stdout.flush() if isinstance(event, fluid.EndEpochEvent): avg_cost, accuracy = trainer.test(reader=test_reader, feed_order=['pixel', 'label']) print('\nTest with Epoch {0}, Loss {1:2.2}, Acc {2:2.2}'.format( event.epoch, avg_cost, accuracy)) if params_dirname is not None: trainer.save_params(params_dirname) #根据配置选择使用CPU资源还是GPU资源 place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() trainer = fluid.Trainer(train_func=train_program, optimizer_func=optimizer_program, place=place) trainer.train(reader=train_reader, num_epochs=EPOCH_NUM, event_handler=event_handler, feed_order=['pixel', 'label'])
def train(use_cuda, train_program, params_dirname): place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() optimizer = fluid.optimizer.SGD(learning_rate=0.2) trainer = fluid.Trainer(train_func=train_program, place=place, optimizer=optimizer) feed_order = [ 'user_id', 'gender_id', 'age_id', 'job_id', 'movie_id', 'category_id', 'movie_title', 'score' ] def event_handler(event): if isinstance(event, fluid.EndStepEvent): test_reader = paddle.batch(paddle.dataset.movielens.test(), batch_size=BATCH_SIZE) avg_cost_set = trainer.test(reader=test_reader, feed_order=feed_order) # get avg cost avg_cost = np.array(avg_cost_set).mean() print("avg_cost: %s" % avg_cost) if float(avg_cost) < 4: # Smaller value to increase CI speed trainer.save_params(params_dirname) trainer.stop() else: print('BatchID {0}, Test Loss {1:0.2}'.format( event.epoch + 1, float(avg_cost))) if math.isnan(float(avg_cost)): sys.exit("got NaN loss, training failed.") train_reader = paddle.batch(paddle.reader.shuffle( paddle.dataset.movielens.train(), buf_size=8192), batch_size=BATCH_SIZE) trainer.train(num_epochs=1, event_handler=event_handler, reader=train_reader, feed_order=feed_order)
def train(use_cuda, train_program, params_dirname): place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() optimizer = fluid.optimizer.Adam(learning_rate=0.001) trainer = fluid.Trainer(train_func=train_program, place=place, optimizer=optimizer, parallel=True) def event_handler(event): if isinstance(event, fluid.EndEpochEvent): test_reader = paddle.batch(paddle.dataset.mnist.test(), batch_size=BATCH_SIZE) avg_cost, acc = trainer.test(reader=test_reader, feed_order=['img', 'label']) print("avg_cost: %s" % avg_cost) print("acc : %s" % acc) if acc > 0.2: # Smaller value to increase CI speed trainer.save_params(params_dirname) else: print('BatchID {0}, Test Loss {1:0.2}, Acc {2:0.2}'.format( event.epoch + 1, avg_cost, acc)) if math.isnan(avg_cost): sys.exit("got NaN loss, training failed.") elif isinstance(event, fluid.EndStepEvent): print("Step {0}, Epoch {1} Metrics {2}".format( event.step, event.epoch, map(numpy.array, event.metrics))) train_reader = paddle.batch(paddle.reader.shuffle( paddle.dataset.mnist.train(), buf_size=500), batch_size=BATCH_SIZE) trainer.train(num_epochs=1, event_handler=event_handler, reader=train_reader, feed_order=['img', 'label'])
def train(use_cuda, train_program, params_dirname): train_filename = './simple-examples/data/ptb.train.txt' test_filename = './simple-examples/data/ptb.valid.txt' train_reader = paddle.batch( reader_creator(data_path, train_filename, word_dict, N), BATCH_SIZE) test_reader = paddle.batch( reader_creator(data_path, test_filename, word_dict, N), BATCH_SIZE) place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() def event_handler(event): if isinstance(event, fluid.EndStepEvent): outs = trainer.test( reader=test_reader, feed_order=['firstw', 'secondw', 'thirdw', 'fourthw', 'nextw']) avg_cost = outs[0] if event.step % 10 == 0: print "Step %d: Average Cost %f" % (event.step, avg_cost) if avg_cost < 5.8: trainer.save_params(params_dirname) trainer.stop() if math.isnan(avg_cost): sys.exit("got NaN loss, training failed.") trainer = fluid.Trainer( train_func=train_program, # optimizer=fluid.optimizer.SGD(learning_rate=0.001), optimizer_func=optimizer_func, place=place) trainer.train( reader=train_reader, num_epochs=1, event_handler=event_handler, feed_order=['firstw', 'secondw', 'thirdw', 'fourthw', 'nextw'])
imgList=[] for row in csvreader: imgList.append(row) random.shuffle(imgList) trainList=imgList[len(imgList)//4:] testList=imgList[:len(imgList)//4] use_cuda=True place=fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() print("prepare trainer") trainer=fluid.Trainer( train_func=train_program, place=place, optimizer_func=optimizer) train_reader=paddle.batch(paddle.reader.shuffle(get_img_reader(path,trainList),buf_size=500),batch_size=64) test_reader=paddle.batch(paddle.reader.shuffle(get_img_reader(path,testList),buf_size=500),batch_size=64) #train_reader=paddle.batch(paddle.reader.shuffle(paddle.dataset.cifar.train10(),buf_size=500),batch_size=64) #test_reader=paddle.batch(paddle.reader.shuffle(paddle.dataset.cifar.test10(),buf_size=500),batch_size=64) print("start train") trainer.train(num_epochs=30, event_handler=event_handler(),
def train(dict_path): word_dict, dict_dim = get_worddict(dict_path) print("[get_worddict] The dictionary size is : %d" % dict_dim) cfg = fluid.CheckpointConfig( checkpoint_dir="/accuracy/checkpoint/text_classification/adam", epoch_interval=1, step_interval=1) #cfg = None trainer = fluid.Trainer(train_func=train_network(dict_dim), place=get_place(), parallel=conf.parallel, optimizer_func=get_optimizer, checkpoint_config=cfg) def event_handler(event): samples = 25000 global step_start_time, epoch_start_time, speeds global accuracies, losses, t_accuracies, t_losses if isinstance(event, fluid.BeginEpochEvent): epoch_start_time = time.time() losses = [] accuracies = [] t_losses = [] t_accuracies = [] if isinstance(event, fluid.BeginStepEvent): if event.epoch == 0 and event.step == 0: speeds = [] step_start_time = time.time() if isinstance(event, fluid.EndStepEvent): loss, accuracy = event.metrics losses.append(loss.mean()) accuracies.append(accuracy.mean()) #t_loss, t_accuracy = trainer.test(reader=test_reader, feed_order=['words', 'label']) t_loss = np.array([0.0]) t_accuracy = np.array([0.0]) print( "Epoch: {0}, Step: {1}, Time: {2}, Loss: {3}, Accuracy: {4}, Test Loss: {5}, Test Accuracy: {6}" .format(event.epoch, event.step, time.time() - step_start_time, loss.mean(), accuracy.mean(), t_loss.mean(), t_accuracy.mean())) t_losses.append(t_loss.mean()) t_accuracies.append(t_accuracy.mean()) if isinstance(event, fluid.EndEpochEvent): epoch_end_time = time.time() time_consuming = epoch_end_time - epoch_start_time speed = samples / time_consuming speeds.append(speed) t_loss, t_accuracy = trainer.test(reader=test_reader, feed_order=['words', 'label']) t_losses.append(t_loss.mean()) t_accuracies.append(t_accuracy.mean()) print( "Epoch: {0},Time: {1}, Speed: {2}, Avg Speed: {3}, Avg Loss: {4}, Avg accuracy: {5}, Test Avg Loss: {6}, Test Avg accuracy: {7}" .format(event.epoch, time_consuming, speed, np.array(speeds).mean(), np.array(losses).mean(), np.array(accuracies).mean(), np.array(t_losses).mean(), np.array(t_accuracies).mean())) train_reader, test_reader = get_reader(word_dict) trainer.train(reader=train_reader, num_epochs=conf.num_passes, event_handler=event_handler, feed_order=['words', 'label'])
def main(): train_reader = paddle.batch(paddle.reader.shuffle( paddle.dataset.mnist.train(), buf_size=500), batch_size=64) test_reader = paddle.batch(paddle.dataset.mnist.test(), batch_size=64) use_cuda = False # set to True if training with GPU place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() trainer = fluid.Trainer(train_func=train_program, place=place, optimizer_func=optimizer_program) # Save the parameter into a directory. The Inferencer can load the parameters from it to do infer params_dirname = "recognize_digits_network.inference.model" lists = [] def event_handler(event): if isinstance(event, fluid.EndStepEvent): if event.step % 100 == 0: # event.metrics maps with train program return arguments. # event.metrics[0] will yeild avg_cost and event.metrics[1] will yeild acc in this example. print "Pass %d, Batch %d, Cost %f" % (event.step, event.epoch, event.metrics[0]) if isinstance(event, fluid.EndEpochEvent): avg_cost, acc = trainer.test(reader=test_reader, feed_order=['img', 'label']) print("Test with Epoch %d, avg_cost: %s, acc: %s" % (event.epoch, avg_cost, acc)) # save parameters trainer.save_params(params_dirname) lists.append((event.epoch, avg_cost, acc)) # Train the model now trainer.train(num_epochs=5, event_handler=event_handler, reader=train_reader, feed_order=['img', 'label']) # find the best pass best = sorted(lists, key=lambda list: float(list[1]))[0] print 'Best pass is %s, testing Avgcost is %s' % (best[0], best[1]) print 'The classification accuracy is %.2f%%' % (float(best[2]) * 100) def load_image(file): im = Image.open(file).convert('L') im = im.resize((28, 28), Image.ANTIALIAS) im = np.array(im).reshape(1, 1, 28, 28).astype(np.float32) im = im / 255.0 * 2.0 - 1.0 return im cur_dir = os.path.dirname(os.path.realpath(__file__)) img = load_image(cur_dir + '/image/infer_3.png') inferencer = fluid.Inferencer( # infer_func=softmax_regression, # uncomment for softmax regression # infer_func=multilayer_perceptron, # uncomment for MLP infer_func=convolutional_neural_network, # uncomment for LeNet5 param_path=params_dirname, place=place) results = inferencer.infer({'img': img}) lab = np.argsort( results) # probs and lab are the results of one batch data print "Label of image/infer_3.png is: %d" % lab[0][0][-1]
y_predict = infer_func() y = fluid.layers.data(name='y', shape=[1], dtype='int64') cost = fluid.layers.cross_entropy(input=y_predict, label=y) avg_cost = fluid.layers.mean(cost) feeder = fluid.DataFeeder(place=place, feed_list=['x', 'y']) return [avg_cost, y_predict] # 这里定义学习率 def optimizer_func(): return fluid.optimizer.Adam(learning_rate=0.0001) # 创建训练器 trainer = fluid.Trainer( train_func= train_func, place= place, optimizer_func= optimizer_func) feed_order=['x','y'] BATCH_SIZE=40 # 设置训练reader train_reader = paddle.batch( paddle.reader.shuffle( read_data(train_set), buf_size=500), batch_size=BATCH_SIZE) #设置测试 reader test_reader = paddle.batch( paddle.reader.shuffle(
# word_dict = paddle.dataset.imdb.word_dict() datas = get_data_from_sql() word_dict = build_dict(datas) print "Reading training data...." # train_reader = paddle.batch( # paddle.reader.shuffle( # paddle.dataset.imdb.train(word_dict), buf_size=25000), batch_size=BATCH_SIZE) train_reader = paddle.batch(paddle.reader.shuffle(train_reader( word_dict, datas), buf_size=25000), batch_size=BATCH_SIZE) print "create trainer...." trainer = fluid.Trainer(train_func=partial(train_program, word_dict), place=place, optimizer_func=optimizer_func) feed_order = ['words', 'label'] print "train start...." trainer.train(num_epochs=1, event_handler=event_handler, reader=train_reader, feed_order=feed_order) inferencer = fluid.Inferencer(infer_func=partial(inference_program, word_dict), param_path=params_dirname, place=place)
def train(dict_path): word_dict, dict_dim = get_worddict(dict_path) print("[get_worddict] The dictionary size is : %d" % dict_dim) training_role = os.getenv("PADDLE_TRAINING_ROLE", "") if training_role == "PSERVER": train_reader = None test_reader = None else: train_reader, test_reader = get_reader(word_dict) trainer = fluid.Trainer( train_func=train_network(dict_dim), place=get_place(), parallel=True, optimizer_func=get_optimizer) def event_handler(event): samples = 25000 global step_start_time, epoch_start_time, speeds global accuracies, losses, t_accuracies, t_losses if isinstance(event, fluid.BeginEpochEvent): epoch_start_time = time.time() losses = [] accuracies = [] t_losses = [] t_accuracies = [] if isinstance(event, fluid.BeginStepEvent): if event.epoch == 0 and event.step == 0: speeds = [] step_start_time = time.time() if isinstance(event, fluid.EndStepEvent): loss, accuracy = as_numpy(event.metrics) losses.append(loss.mean()) accuracies.append(accuracy.mean()) t_loss, t_accuracy = trainer.test(reader=test_reader, feed_order=['words', 'label']) t_losses.append(t_loss.mean()) t_accuracies.append(t_accuracy.mean()) if isinstance(event, fluid.EndEpochEvent): epoch_end_time = time.time() time_consuming = epoch_end_time-epoch_start_time speed = samples/time_consuming speeds.append(speed) print("Epoch: {0},Time: {1}, Speed: {2}, Avg Speed: {3}, Avg Loss: {4}, Avg accuracy: {5}".format( event.epoch, time_consuming, speed, np.array(speeds).mean(), np.array(losses).mean(), np.array(accuracies).mean())) print("Epoch: {0},Test Avg Loss: {1}, Test Avg accuracy: {2}".format( event.epoch, np.array(t_losses).mean(), np.array(t_accuracies).mean())) trainer.train(reader=train_reader, num_epochs=conf.num_passes, event_handler=event_handler, feed_order=['words', 'label'])
def train(args): # logger = LogWriter(args.logdir, sync_cycle=10000) model = resnet class_dim = args.class_dim if args.data_format == 'NCHW': dshape = [3, 224, 224] else: dshape = [224, 224, 3] if not args.data_path: raise Exception( "Must specify --data_path when training with dog vs cat") train_reader, test_reader = dataset(args.data_path) print(train_reader) def train_network(): input = fluid.layers.data(name='image', shape=dshape, dtype='float32') predict = model(input, class_dim) label = fluid.layers.data(name='label', shape=[1], dtype='int64') cost = fluid.layers.cross_entropy(input=predict, label=label) avg_cost = fluid.layers.mean(x=cost) batch_acc = fluid.layers.accuracy(input=predict, label=label) return [avg_cost, batch_acc] # scalar_avg_cost = logger.scalar("avg_cost") # scalar_batch_acc = logger.scalar("batch_acc") #train_program = avg_cost optimizer = fluid.optimizer.Momentum(learning_rate=0.01, momentum=0.9) batched_train_reader = paddle.batch(paddle.reader.shuffle(train_reader, buf_size=5120), batch_size=args.batch_size) batched_test_reader = paddle.batch(test_reader, batch_size=args.batch_size) def event_handler(event): if isinstance(event, fluid.EndStepEvent): # scalar_avg_cost.add_record() #avg_cost, accuracy = trainer.test( # reader=batched_test_reader, feed_order=['image', 'label']) print('Pass:{0},Step: {1},Metric: {2}'.format( event.epoch, event.step, event.metrics)) # write the loss, acc to visualdl file if isinstance(event, fluid.EndEpochEvent): # save model to dir #trainer.save_params(".") avg_cost, acc = trainer.test(reader=batched_test_reader, feed_order=["image", "label"]) print('Pass:{0},val avg_cost: {1}, acc: {2}'.format( event.epoch, avg_cost, acc)) trainer.save_params("./ckpt") # write the loss, acc to visualdl file pass # place = fluid.CUDAPlace(0) if args.use_cuda else fluid.CPUPlace() place = fluid.CUDAPlace(0) trainer = fluid.Trainer(train_func=train_network, optimizer=optimizer, place=place) print("Begin to Train") trainer.train(reader=batched_train_reader, num_epochs=args.pass_num, event_handler=event_handler, feed_order=['image', 'label'])
def make_cnn_model_visualization(dirname): """ Train the cnn model on mnist datasets """ batch_size = 64 num_epochs = 5 use_cuda = 1 def optimizer_program(): return fluid.optimizer.Adam(learning_rate=0.001) def train_program(): label = fluid.layers.data(name='label', shape=[1], dtype='int64') img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32') predict = mnist_mlp_model(img) # Calculate the cost from the prediction and label. cost = fluid.layers.cross_entropy(input=predict, label=label) avg_cost = fluid.layers.mean(cost) acc = fluid.layers.accuracy(input=predict, label=label) return [avg_cost, acc] train_reader = paddle.batch(paddle.reader.shuffle( paddle.dataset.mnist.train(), buf_size=500), batch_size=batch_size) test_reader = paddle.batch(paddle.dataset.mnist.test(), batch_size=batch_size) # set to True if training with GPU place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() trainer = fluid.Trainer(train_func=train_program, place=place, optimizer_func=optimizer_program) # Save the parameter into a directory. The Inferencer can load the parameters from it to do infer params_dirname = dirname lists = [] def event_handler(event): if isinstance(event, fluid.EndStepEvent): if event.step % 100 == 0: # event.metrics maps with train program return arguments. # event.metrics[0] will yeild avg_cost and event.metrics[1] will yeild acc in this example. print "step %d, epoch %d, Cost %f Acc %f " % ( event.step, event.epoch, event.metrics[0], event.metrics[1]) if isinstance(event, fluid.EndEpochEvent): avg_cost, acc = trainer.test(reader=test_reader, feed_order=['img', 'label']) print("Test with Epoch %d, avg_cost: %s, acc: %s" % (event.epoch, avg_cost, acc)) # save parameters print "save_params" trainer.save_params(params_dirname) lists.append((event.epoch, avg_cost, acc)) # Train the model now trainer.train(num_epochs=num_epochs, event_handler=event_handler, reader=train_reader, feed_order=['img', 'label']) # find the best pass best = sorted(lists, key=lambda list: float(list[1]))[0] print 'Best pass is %s, testing Avgcost is %s' % (best[0], best[1]) print 'The classification accuracy is %.2f%%' % (float(best[2]) * 100)
def create_model(): def create_discriminator(discrim_inputs, discrim_targets): n_layers = 3 layers = [] # 2x [batch, in_channels, height, width] => [batch, in_channels * 2, height, width] input = fluid.layers.concat(input=[discrim_inputs, discrim_targets], axis=1) # layer_1: [batch, in_channels * 2, 256, 256] => [batch, ndf, 128, 128] convolved = discrim_conv(input, a.ndf, stride=2) rectified = utils.lrelu(convolved, 0.2) layers.append(rectified) # layer_2: [batch, 128, 128, ndf] => [batch, 64, 64, ndf * 2] # layer_3: [batch, 64, 64, ndf * 2] => [batch, 32, 32, ndf * 4] # layer_4: [batch, 32, 32, ndf * 4] => [batch, 31, 31, ndf * 8] for i in range(n_layers): out_channels = a.ndf * min(2 ** (i + 1), 8) stride = 1 if i == n_layers - 1 else 2 # last layer here has stride 1 convolved = discrim_conv(layers[-1], out_channels, stride=stride) normalized = utils.batchnorm(convolved) rectified = utils.lrelu(normalized, 0.2) layers.append(rectified) # layer_5: [batch, 31, 31, ndf * 8] => [batch, 30, 30, 1] convolved = discrim_conv(rectified, out_channels=1, stride=1) output = fluid.layers.sigmoid(convolved) layers.append(output) return layers[-1] def discrim_train_program(): inputs = fluid.layers.data(name='input_images', shape=[3, CROP_SIZE, CROP_SIZE], dtype='float32') targets = fluid.layers.data(name='target_images', shape=[3, CROP_SIZE, CROP_SIZE], dtype='float32') out_channels = 3 # int(targets.get_shape()[-1]) outputs = create_generator(inputs, out_channels) # create two copies of discriminator, one for real pairs and one for fake pairs # they share the same underlying variables # 2x [batch, height, width, channels] => [batch, 30, 30, 1] predict_real = create_discriminator(inputs, targets) # with tf.variable_scope("discriminator", reuse=True): # 2x [batch, height, width, channels] => [batch, 30, 30, 1] predict_fake = create_discriminator(inputs, outputs) # minimizing -tf.log will try to get inputs to 1 # predict_real => 1 # predict_fake => 0 discrim_loss = fluid.layers.reduce_mean( fluid.layers.sum( fluid.layers.scale( x=fluid.layers.log(predict_real + EPS), scale=-1.0), fluid.layers.log(1 - predict_fake + EPS) ) ) return [discrim_loss] def discrim_optimizer_program(): return fluid.optimizer.AdamOptimizer(learning_rate=a.lr, beta1=a.beta1) use_cuda = a.use_cuda place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() checkpoint_config = fluid.CheckpointConfig("./checkpoints") discrim_trainer = fluid.Trainer(train_func=discrim_train_program, place=place, optimizer_func=discrim_optimizer_program, checkpoint_config=checkpoint_config) def gen_train_program(): inputs = fluid.layers.data(name='input_images', shape=[3, CROP_SIZE, CROP_SIZE], dtype='float32') targets = fluid.layers.data(name='target_images', shape=[3, CROP_SIZE, CROP_SIZE], dtype='float32') out_channels = 3 outputs = create_generator(inputs, out_channels) # create two copies of discriminator, one for real pairs and one for fake pairs # they share the same underlying variables # 2x [batch, height, width, channels] => [batch, 30, 30, 1] predict_real = create_discriminator(inputs, targets) # 2x [batch, height, width, channels] => [batch, 30, 30, 1] predict_fake = create_discriminator(inputs, outputs) # predict_fake => 1 # abs(targets - outputs) => 0 gen_loss_GAN = fluid.layers.reduce_mean( fluid.layers.scale( x=fluid.layers.log(predict_fake + EPS), scale=-1.0 ) ) gen_loss_L1 = fluid.layers.reduce_mean( fluid.layers.abs(targets - outputs)) gen_loss = fluid.layers.scale(x=gen_loss_GAN, scale=a.gan_weight) + fluid.layers.scale(x=gen_loss_L1, scale=a.l1_weight) return [gen_loss] def gen_optimizer_program(): return fluid.optimizer.AdamOptimizer(learning_rate=a.lr, beta1=a.beta1) gen_trainer = fluid.Trainer(train_func=gen_train_program, place=place, optimizer_func=gen_optimizer_program, checkpoint_config=checkpoint_config) # TODO: https://github.com/PaddlePaddle/Paddle/issues/7785 # ExponentialMovingAverage() return Model( discrim_trainer=discrim_trainer, gen_trainer=gen_trainer, )