remove unused fc_gan unit-test demo (#26889)
Tao Luo
5 years ago
committed by
GitHub
parent
030b298e82
commit
bf6cbbc745
@ -1,96 +0,0 @@
|
||||
# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
import tarfile
|
||||
import paddle.fluid as fluid
|
||||
import paddle
|
||||
from paddle.fluid import core
|
||||
|
||||
URL = 'http://paddle-unittest-data.gz.bcebos.com/python_paddle_fluid_tests_demo_async-executor/train_data.tar.gz'
|
||||
MD5 = '2a405a31508969b3ab823f42c0f522ca'
|
||||
|
||||
|
||||
def bow_net(data,
|
||||
label,
|
||||
dict_dim=89528,
|
||||
emb_dim=128,
|
||||
hid_dim=128,
|
||||
hid_dim2=96,
|
||||
class_dim=2):
|
||||
"""
|
||||
BOW net
|
||||
This model is from https://github.com/PaddlePaddle/models:
|
||||
models/fluid/PaddleNLP/text_classification/nets.py
|
||||
"""
|
||||
# embedding
|
||||
emb = fluid.layers.embedding(
|
||||
input=data, size=[dict_dim, emb_dim], is_sparse=True)
|
||||
bow = fluid.layers.sequence_pool(input=emb, pool_type='sum')
|
||||
bowh = fluid.layers.tanh(bow)
|
||||
# fc layer after conv
|
||||
fc_1 = fluid.layers.fc(input=bowh, size=hid_dim, act="tanh")
|
||||
fc_2 = fluid.layers.fc(input=fc_1, size=hid_dim2, act="tanh")
|
||||
# probability of each class
|
||||
prediction = fluid.layers.fc(input=[fc_2], size=class_dim, act="softmax")
|
||||
# cross entropy loss
|
||||
cost = fluid.layers.cross_entropy(input=prediction, label=label)
|
||||
# mean loss
|
||||
avg_cost = fluid.layers.mean(x=cost)
|
||||
acc = fluid.layers.accuracy(input=prediction, label=label)
|
||||
return avg_cost, acc, prediction
|
||||
|
||||
|
||||
def train():
|
||||
# Download data
|
||||
with tarfile.open(paddle.dataset.common.download(URL, "imdb", MD5)) as tarf:
|
||||
tarf.extractall(path='./')
|
||||
tarf.close()
|
||||
|
||||
# Initialize dataset description
|
||||
dataset = fluid.DatasetFactory().create_dataset()
|
||||
dataset.set_batch_size(128) # See API doc for how to change other fields
|
||||
|
||||
# define network
|
||||
# input text data
|
||||
data = fluid.layers.data(
|
||||
name="words", shape=[1], dtype="int64", lod_level=1)
|
||||
# label data
|
||||
label = fluid.layers.data(name="label", shape=[1], dtype="int64")
|
||||
dataset.set_use_var([data, label])
|
||||
avg_cost, acc, prediction = bow_net(data, label)
|
||||
sgd_optimizer = fluid.optimizer.Adagrad(learning_rate=0.002)
|
||||
opt_ops, weight_and_grad = sgd_optimizer.minimize(avg_cost)
|
||||
|
||||
# Run startup program
|
||||
startup_program = fluid.default_startup_program()
|
||||
place = fluid.CPUPlace()
|
||||
executor = fluid.Executor(place)
|
||||
executor.run(startup_program)
|
||||
|
||||
main_program = fluid.default_main_program()
|
||||
epochs = 10
|
||||
filelist = ["train_data/part-%d" % i for i in range(12)]
|
||||
dataset.set_filelist(filelist)
|
||||
for i in range(epochs):
|
||||
dataset.set_thread(4)
|
||||
executor.train_from_dataset(
|
||||
main_program, # This can be changed during iteration
|
||||
dataset, # This can be changed during iteration
|
||||
debug=False)
|
||||
fluid.io.save_inference_model('imdb/epoch%d.model' % i,
|
||||
[data.name, label.name], [acc], executor)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
train()
|
||||
@ -1,173 +0,0 @@
|
||||
# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
from __future__ import print_function
|
||||
|
||||
import errno
|
||||
import math
|
||||
import os
|
||||
|
||||
import matplotlib
|
||||
import numpy
|
||||
|
||||
import paddle
|
||||
import paddle.fluid as fluid
|
||||
|
||||
matplotlib.use('Agg')
|
||||
import matplotlib.pyplot as plt
|
||||
import matplotlib.gridspec as gridspec
|
||||
|
||||
NOISE_SIZE = 100
|
||||
NUM_PASS = 1000
|
||||
NUM_REAL_IMGS_IN_BATCH = 121
|
||||
NUM_TRAIN_TIMES_OF_DG = 3
|
||||
LEARNING_RATE = 2e-5
|
||||
|
||||
|
||||
def D(x):
|
||||
hidden = fluid.layers.fc(input=x,
|
||||
size=200,
|
||||
act='relu',
|
||||
param_attr='D.w1',
|
||||
bias_attr='D.b1')
|
||||
logits = fluid.layers.fc(input=hidden,
|
||||
size=1,
|
||||
act=None,
|
||||
param_attr='D.w2',
|
||||
bias_attr='D.b2')
|
||||
return logits
|
||||
|
||||
|
||||
def G(x):
|
||||
hidden = fluid.layers.fc(input=x,
|
||||
size=200,
|
||||
act='relu',
|
||||
param_attr='G.w1',
|
||||
bias_attr='G.b1')
|
||||
img = fluid.layers.fc(input=hidden,
|
||||
size=28 * 28,
|
||||
act='tanh',
|
||||
param_attr='G.w2',
|
||||
bias_attr='G.b2')
|
||||
return img
|
||||
|
||||
|
||||
def plot(gen_data):
|
||||
gen_data.resize(gen_data.shape[0], 28, 28)
|
||||
n = int(math.ceil(math.sqrt(gen_data.shape[0])))
|
||||
fig = plt.figure(figsize=(n, n))
|
||||
gs = gridspec.GridSpec(n, n)
|
||||
gs.update(wspace=0.05, hspace=0.05)
|
||||
|
||||
for i, sample in enumerate(gen_data):
|
||||
ax = plt.subplot(gs[i])
|
||||
plt.axis('off')
|
||||
ax.set_xticklabels([])
|
||||
ax.set_yticklabels([])
|
||||
ax.set_aspect('equal')
|
||||
plt.imshow(sample.reshape(28, 28), cmap='Greys_r')
|
||||
|
||||
return fig
|
||||
|
||||
|
||||
def main():
|
||||
try:
|
||||
os.makedirs("./out")
|
||||
except OSError as e:
|
||||
if e.errno != errno.EEXIST:
|
||||
raise
|
||||
|
||||
startup_program = fluid.Program()
|
||||
d_program = fluid.Program()
|
||||
dg_program = fluid.Program()
|
||||
|
||||
with fluid.program_guard(d_program, startup_program):
|
||||
img = fluid.layers.data(name='img', shape=[784], dtype='float32')
|
||||
d_loss = fluid.layers.sigmoid_cross_entropy_with_logits(
|
||||
x=D(img),
|
||||
label=fluid.layers.data(
|
||||
name='label', shape=[1], dtype='float32'))
|
||||
d_loss = fluid.layers.mean(d_loss)
|
||||
|
||||
with fluid.program_guard(dg_program, startup_program):
|
||||
noise = fluid.layers.data(
|
||||
name='noise', shape=[NOISE_SIZE], dtype='float32')
|
||||
g_img = G(x=noise)
|
||||
g_program = dg_program.clone()
|
||||
dg_loss = fluid.layers.sigmoid_cross_entropy_with_logits(
|
||||
x=D(g_img),
|
||||
label=fluid.layers.fill_constant_batch_size_like(
|
||||
input=noise, dtype='float32', shape=[-1, 1], value=1.0))
|
||||
dg_loss = fluid.layers.mean(dg_loss)
|
||||
|
||||
opt = fluid.optimizer.Adam(learning_rate=LEARNING_RATE)
|
||||
|
||||
opt.minimize(loss=d_loss, startup_program=startup_program)
|
||||
opt.minimize(
|
||||
loss=dg_loss,
|
||||
startup_program=startup_program,
|
||||
parameter_list=[
|
||||
p.name for p in g_program.global_block().all_parameters()
|
||||
])
|
||||
exe = fluid.Executor(fluid.CPUPlace())
|
||||
exe.run(startup_program)
|
||||
|
||||
num_true = NUM_REAL_IMGS_IN_BATCH
|
||||
train_reader = paddle.batch(
|
||||
paddle.reader.shuffle(
|
||||
paddle.dataset.mnist.train(), buf_size=60000),
|
||||
batch_size=num_true)
|
||||
|
||||
for pass_id in range(NUM_PASS):
|
||||
for batch_id, data in enumerate(train_reader()):
|
||||
num_true = len(data)
|
||||
n = numpy.random.uniform(
|
||||
low=-1.0, high=1.0,
|
||||
size=[num_true * NOISE_SIZE]).astype('float32').reshape(
|
||||
[num_true, NOISE_SIZE])
|
||||
generated_img = exe.run(g_program,
|
||||
feed={'noise': n},
|
||||
fetch_list={g_img})[0]
|
||||
real_data = numpy.array([x[0] for x in data]).astype('float32')
|
||||
real_data = real_data.reshape(num_true, 784)
|
||||
total_data = numpy.concatenate([real_data, generated_img])
|
||||
total_label = numpy.concatenate([
|
||||
numpy.ones(
|
||||
shape=[real_data.shape[0], 1], dtype='float32'),
|
||||
numpy.zeros(
|
||||
shape=[real_data.shape[0], 1], dtype='float32')
|
||||
])
|
||||
d_loss_np = exe.run(d_program,
|
||||
feed={'img': total_data,
|
||||
'label': total_label},
|
||||
fetch_list={d_loss})[0]
|
||||
for _ in range(NUM_TRAIN_TIMES_OF_DG):
|
||||
n = numpy.random.uniform(
|
||||
low=-1.0, high=1.0,
|
||||
size=[2 * num_true * NOISE_SIZE]).astype('float32').reshape(
|
||||
[2 * num_true, NOISE_SIZE, 1, 1])
|
||||
dg_loss_np = exe.run(dg_program,
|
||||
feed={'noise': n},
|
||||
fetch_list={dg_loss})[0]
|
||||
print("Pass ID={0}, Batch ID={1}, D-Loss={2}, DG-Loss={3}".format(
|
||||
pass_id, batch_id, d_loss_np, dg_loss_np))
|
||||
# generate image each batch
|
||||
fig = plot(generated_img)
|
||||
plt.savefig(
|
||||
'out/{0}.png'.format(str(pass_id).zfill(3)), bbox_inches='tight')
|
||||
plt.close(fig)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@ -1,205 +0,0 @@
|
||||
# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserve.
|
||||
#
|
||||
#Licensed under the Apache License, Version 2.0 (the "License");
|
||||
#you may not use this file except in compliance with the License.
|
||||
#You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
#Unless required by applicable law or agreed to in writing, software
|
||||
#distributed under the License is distributed on an "AS IS" BASIS,
|
||||
#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
#See the License for the specific language governing permissions and
|
||||
#limitations under the License.
|
||||
|
||||
import numpy as np
|
||||
import copy
|
||||
import pickle
|
||||
import os
|
||||
from functools import partial
|
||||
import logging
|
||||
import time
|
||||
import paddle
|
||||
import paddle.fluid as fluid
|
||||
import paddle.fluid.layers as layers
|
||||
import argparse
|
||||
import random
|
||||
import sys
|
||||
import math
|
||||
|
||||
logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s')
|
||||
logger = logging.getLogger("fluid")
|
||||
logger.setLevel(logging.INFO)
|
||||
|
||||
is_profile = False
|
||||
|
||||
|
||||
def parse_args():
|
||||
parser = argparse.ArgumentParser("Resnet with pipelie parallel.")
|
||||
parser.add_argument(
|
||||
'--batch_size', type=int, default=100, help='input batch size')
|
||||
parser.add_argument('--lr', type=float, default=0.001, help='learning rate')
|
||||
return parser.parse_args()
|
||||
|
||||
|
||||
def conv_bn_layer(input, num_filters, filter_size, stride=1, groups=1,
|
||||
act=None):
|
||||
conv = fluid.layers.conv2d(
|
||||
input=input,
|
||||
num_filters=num_filters,
|
||||
filter_size=filter_size,
|
||||
stride=stride,
|
||||
padding=(filter_size - 1) // 2,
|
||||
groups=groups,
|
||||
act=None,
|
||||
bias_attr=False)
|
||||
return fluid.layers.batch_norm(
|
||||
input=conv,
|
||||
act=act, )
|
||||
|
||||
|
||||
def shortcut(input, ch_out, stride, is_first):
|
||||
ch_in = input.shape[1]
|
||||
if ch_in != ch_out or stride != 1 or is_first == True:
|
||||
return conv_bn_layer(input, ch_out, 1, stride)
|
||||
else:
|
||||
return input
|
||||
|
||||
|
||||
def bottleneck_block(input, num_filters, stride):
|
||||
conv0 = conv_bn_layer(
|
||||
input=input, num_filters=num_filters, filter_size=1, act='relu')
|
||||
conv1 = conv_bn_layer(
|
||||
input=conv0,
|
||||
num_filters=num_filters,
|
||||
filter_size=3,
|
||||
stride=stride,
|
||||
act='relu')
|
||||
conv2 = conv_bn_layer(
|
||||
input=conv1, num_filters=num_filters * 4, filter_size=1, act=None)
|
||||
|
||||
short = shortcut(input, num_filters * 4, stride, is_first=False)
|
||||
|
||||
return fluid.layers.elementwise_add(x=short, y=conv2, act='relu')
|
||||
|
||||
|
||||
def basic_block(input, num_filters, stride, is_first):
|
||||
conv0 = conv_bn_layer(
|
||||
input=input,
|
||||
num_filters=num_filters,
|
||||
filter_size=3,
|
||||
act='relu',
|
||||
stride=stride)
|
||||
conv1 = conv_bn_layer(
|
||||
input=conv0, num_filters=num_filters, filter_size=3, act=None)
|
||||
short = shortcut(input, num_filters, stride, is_first)
|
||||
return fluid.layers.elementwise_add(x=short, y=conv1, act='relu')
|
||||
|
||||
|
||||
def network(input, layers=50, class_dim=1000):
|
||||
supported_layers = [18, 34, 50, 101, 152]
|
||||
assert layers in supported_layers
|
||||
depth = None
|
||||
if layers == 18:
|
||||
depth = [2, 2, 2, 2]
|
||||
elif layers == 34 or layers == 50:
|
||||
depth = [3, 4, 6, 3]
|
||||
elif layers == 101:
|
||||
depth = [3, 4, 23, 3]
|
||||
elif layers == 152:
|
||||
depth = [3, 8, 36, 3]
|
||||
num_filters = [64, 128, 256, 512]
|
||||
with fluid.device_guard("gpu:0"):
|
||||
conv = conv_bn_layer(
|
||||
input=input, num_filters=64, filter_size=7, stride=2, act='relu')
|
||||
conv = fluid.layers.pool2d(
|
||||
input=conv,
|
||||
pool_size=3,
|
||||
pool_stride=2,
|
||||
pool_padding=1,
|
||||
pool_type='max')
|
||||
if layers >= 50:
|
||||
for block in range(len(depth)):
|
||||
with fluid.device_guard("gpu:1"):
|
||||
for i in range(depth[block]):
|
||||
conv = bottleneck_block(
|
||||
input=conv,
|
||||
num_filters=num_filters[block],
|
||||
stride=2 if i == 0 and block != 0 else 1)
|
||||
|
||||
with fluid.device_guard("gpu:2"):
|
||||
pool = fluid.layers.pool2d(
|
||||
input=conv, pool_size=7, pool_type='avg', global_pooling=True)
|
||||
stdv = 1.0 / math.sqrt(pool.shape[1] * 1.0)
|
||||
out = fluid.layers.fc(
|
||||
input=pool,
|
||||
size=class_dim,
|
||||
param_attr=fluid.param_attr.ParamAttr(
|
||||
initializer=fluid.initializer.Uniform(-stdv, stdv)))
|
||||
else:
|
||||
for block in range(len(depth)):
|
||||
with fluid.device_guard("gpu:1"):
|
||||
for i in range(depth[block]):
|
||||
conv = basic_block(
|
||||
input=conv,
|
||||
num_filters=num_filters[block],
|
||||
stride=2 if i == 0 and block != 0 else 1,
|
||||
is_first=block == i == 0)
|
||||
with fluid.device_guard("gpu:2"):
|
||||
pool = fluid.layers.pool2d(
|
||||
input=conv, pool_size=7, pool_type='avg', global_pooling=True)
|
||||
stdv = 1.0 / math.sqrt(pool.shape[1] * 1.0)
|
||||
out = fluid.layers.fc(
|
||||
input=pool,
|
||||
size=class_dim,
|
||||
param_attr=fluid.param_attr.ParamAttr(
|
||||
initializer=fluid.initializer.Uniform(-stdv, stdv)))
|
||||
return out
|
||||
|
||||
|
||||
def train():
|
||||
args = parse_args()
|
||||
lr = args.lr
|
||||
|
||||
with fluid.device_guard("gpu:0"):
|
||||
image = fluid.layers.data(
|
||||
name="image", shape=[3, 224, 224], dtype="float32")
|
||||
label = fluid.layers.data(name="label", shape=[1], dtype="int64")
|
||||
data_loader = fluid.io.DataLoader.from_generator(
|
||||
feed_list=[image, label],
|
||||
capacity=64,
|
||||
use_double_buffer=True,
|
||||
iterable=False)
|
||||
fc = build_network(image, layers=50)
|
||||
|
||||
with fluid.device_guard("gpu:3"):
|
||||
out, prob = fluid.layers.softmax_with_cross_entropy(
|
||||
logits=fc, label=label, return_softmax=True)
|
||||
loss = fluid.layers.mean(out)
|
||||
acc_top1 = fluid.layers.accuracy(input=prob, label=label, k=1)
|
||||
acc_top5 = fluid.layers.accuracy(input=prob, label=label, k=5)
|
||||
|
||||
optimizer = fluid.optimizer.SGD(lr)
|
||||
optimizer = fluid.optimizer.PipelineOptimizer(optimizer, num_microbatches=2)
|
||||
optimizer.minimize(loss)
|
||||
|
||||
def train_reader():
|
||||
for _ in range(4000):
|
||||
img = np.random.random(size=[3, 224, 224]).astype('float32')
|
||||
label = np.random.random(size=[1]).astype('int64')
|
||||
yield img, label
|
||||
|
||||
data_loader.set_sample_generator(train_reader, batch_size=args.batch_size)
|
||||
|
||||
place = fluid.CUDAPlace(0)
|
||||
exe = fluid.Executor(place)
|
||||
|
||||
exe.run(fluid.default_startup_program())
|
||||
|
||||
data_loader.start()
|
||||
logger.info("begin training...")
|
||||
exe.train_from_dataset(fluid.default_main_program(), debug=is_profile)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
train()
|
||||
@ -1,102 +0,0 @@
|
||||
# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
from __future__ import print_function
|
||||
|
||||
import numpy
|
||||
import six
|
||||
|
||||
import paddle
|
||||
import paddle.dataset.mnist as mnist
|
||||
import paddle.fluid as fluid
|
||||
|
||||
|
||||
def network(is_train):
|
||||
reader = fluid.layers.py_reader(
|
||||
capacity=10,
|
||||
shapes=((-1, 784), (-1, 1)),
|
||||
dtypes=('float32', 'int64'),
|
||||
name="train_reader" if is_train else "test_reader",
|
||||
use_double_buffer=True)
|
||||
img, label = fluid.layers.read_file(reader)
|
||||
|
||||
hidden = img
|
||||
|
||||
for i in six.moves.xrange(2):
|
||||
hidden = fluid.layers.fc(input=hidden, size=100, act='tanh')
|
||||
hidden = fluid.layers.dropout(
|
||||
hidden, dropout_prob=0.5, is_test=not is_train)
|
||||
|
||||
prediction = fluid.layers.fc(input=hidden, size=10, act='softmax')
|
||||
loss = fluid.layers.cross_entropy(input=prediction, label=label)
|
||||
return fluid.layers.mean(loss), reader
|
||||
|
||||
|
||||
def main():
|
||||
train_prog = fluid.Program()
|
||||
startup_prog = fluid.Program()
|
||||
|
||||
with fluid.program_guard(train_prog, startup_prog):
|
||||
with fluid.unique_name.guard():
|
||||
loss, train_reader = network(True)
|
||||
adam = fluid.optimizer.Adam(learning_rate=0.01)
|
||||
adam.minimize(loss)
|
||||
|
||||
test_prog = fluid.Program()
|
||||
test_startup = fluid.Program()
|
||||
with fluid.program_guard(test_prog, test_startup):
|
||||
with fluid.unique_name.guard():
|
||||
test_loss, test_reader = network(False)
|
||||
|
||||
use_cuda = fluid.core.is_compiled_with_cuda()
|
||||
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
|
||||
fluid.Executor(place).run(startup_prog)
|
||||
fluid.Executor(place).run(test_startup)
|
||||
|
||||
trainer = fluid.ParallelExecutor(
|
||||
use_cuda=use_cuda, loss_name=loss.name, main_program=train_prog)
|
||||
|
||||
tester = fluid.ParallelExecutor(
|
||||
use_cuda=use_cuda, share_vars_from=trainer, main_program=test_prog)
|
||||
|
||||
train_reader.decorate_paddle_reader(
|
||||
paddle.reader.shuffle(
|
||||
paddle.batch(mnist.train(), 512), buf_size=8192))
|
||||
|
||||
test_reader.decorate_paddle_reader(paddle.batch(mnist.test(), 512))
|
||||
|
||||
for epoch_id in six.moves.xrange(10):
|
||||
train_reader.start()
|
||||
try:
|
||||
while True:
|
||||
print(
|
||||
'train_loss',
|
||||
numpy.array(trainer.run(fetch_list=[loss.name])))
|
||||
except fluid.core.EOFException:
|
||||
print('End of epoch', epoch_id)
|
||||
train_reader.reset()
|
||||
|
||||
test_reader.start()
|
||||
try:
|
||||
while True:
|
||||
print(
|
||||
'test loss',
|
||||
numpy.array(tester.run(fetch_list=[test_loss.name])))
|
||||
except fluid.core.EOFException:
|
||||
print('End of testing')
|
||||
test_reader.reset()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
Loading…
Reference in new issue