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