def main():
paddle.enable_static()
place = paddle.CUDAPlace(0) if FLAGS.use_gpu else paddle.CPUPlace()
resize_size, crop_size = (256, 224)
val_dataset = paddlevision.datasets.ImageFolder(
os.path.join(FLAGS.data_dir, 'val'),
ClassificationPresetEval(
crop_size=crop_size, resize_size=resize_size))
data_loader = paddle.io.DataLoader(
val_dataset, places=place, batch_size=FLAGS.batch_size)
quant_output_dir = os.path.join(FLAGS.output_dir, "mv3_int8_infer")
exe = paddle.static.Executor(place)
quant_post_static(
executor=exe,
model_dir=FLAGS.model_path,
quantize_model_path=quant_output_dir,
sample_generator=sample_generator(data_loader),
model_filename=FLAGS.model_filename,
params_filename=FLAGS.params_filename,
batch_size=FLAGS.batch_size,
batch_nums=FLAGS.batch_num,
save_model_filename=FLAGS.save_model_filename,
save_params_filename=FLAGS.params_filename',
algo=FLAGS.algo,
hist_percent=FLAGS.hist_percent)
def quantize(args):
shuffle = True
if args.ce_test:
# set seed
seed = 111
np.random.seed(seed)
paddle.seed(seed)
random.seed(seed)
shuffle = False
place = paddle.CUDAPlace(0) if args.use_gpu else paddle.CPUPlace()
val_dataset = reader.ImageNetDataset(mode='test')
image_shape = [3, 224, 224]
image = paddle.static.data(name=args.input_name,
shape=[None] + image_shape,
dtype='float32')
data_loader = paddle.io.DataLoader(val_dataset,
places=place,
feed_list=[image],
drop_last=False,
return_list=False,
batch_size=args.batch_size,
shuffle=False)
assert os.path.exists(args.model_path), "args.model_path doesn't exist"
assert os.path.isdir(args.model_path), "args.model_path must be a dir"
exe = paddle.static.Executor(place)
quant_post_static(executor=exe,
model_dir=args.model_path,
quantize_model_path=args.save_path,
data_loader=data_loader,
model_filename=args.model_filename,
params_filename=args.params_filename,
batch_size=args.batch_size,
batch_nums=args.batch_num,
algo=args.algo,
round_type=args.round_type,
hist_percent=args.hist_percent,
is_full_quantize=args.is_full_quantize,
bias_correction=args.bias_correction,
onnx_format=args.onnx_format)
def quantize(args):
val_reader = reader.train()
place = paddle.CUDAPlace(0) if args.use_gpu else paddle.CPUPlace()
assert os.path.exists(args.model_path), "args.model_path doesn't exist"
assert os.path.isdir(args.model_path), "args.model_path must be a dir"
exe = paddle.static.Executor(place)
quant_post_static(executor=exe,
model_dir=args.model_path,
quantize_model_path=args.save_path,
sample_generator=val_reader,
model_filename=args.model_filename,
params_filename=args.params_filename,
batch_size=args.batch_size,
batch_nums=args.batch_num,
algo=args.algo,
hist_percent=args.hist_percent,
bias_correction=args.bias_correction)
def test_accuracy(self):
image = paddle.static.data(name='image',
shape=[None, 1, 28, 28],
dtype='float32')
label = paddle.static.data(name='label',
shape=[None, 1],
dtype='int64')
model = MobileNet()
out = model.net(input=image, class_dim=10)
cost = paddle.nn.functional.loss.cross_entropy(input=out, label=label)
avg_cost = paddle.mean(x=cost)
acc_top1 = paddle.metric.accuracy(input=out, label=label, k=1)
acc_top5 = paddle.metric.accuracy(input=out, label=label, k=5)
optimizer = paddle.optimizer.Momentum(
momentum=0.9,
learning_rate=0.01,
weight_decay=paddle.regularizer.L2Decay(4e-5))
optimizer.minimize(avg_cost)
main_prog = paddle.static.default_main_program()
val_prog = main_prog.clone(for_test=True)
place = paddle.CUDAPlace(
0) if paddle.is_compiled_with_cuda() else paddle.CPUPlace()
exe = paddle.static.Executor(place)
exe.run(paddle.static.default_startup_program())
def transform(x):
return np.reshape(x, [1, 28, 28])
train_dataset = paddle.vision.datasets.MNIST(mode='train',
backend='cv2',
transform=transform)
test_dataset = paddle.vision.datasets.MNIST(mode='test',
backend='cv2',
transform=transform)
train_loader = paddle.io.DataLoader(train_dataset,
places=place,
feed_list=[image, label],
drop_last=True,
batch_size=64,
return_list=False)
valid_loader = paddle.io.DataLoader(test_dataset,
places=place,
feed_list=[image, label],
batch_size=64,
return_list=False)
def sample_generator_creator():
def __reader__():
for data in test_dataset:
image, label = data
yield image, label
return __reader__
def train(program):
iter = 0
for data in train_loader():
cost, top1, top5 = exe.run(
program,
feed=data,
fetch_list=[avg_cost, acc_top1, acc_top5])
iter += 1
if iter % 100 == 0:
print(
'train iter={}, avg loss {}, acc_top1 {}, acc_top5 {}'.
format(iter, cost, top1, top5))
def test(program, outputs=[avg_cost, acc_top1, acc_top5]):
iter = 0
result = [[], [], []]
for data in valid_loader():
cost, top1, top5 = exe.run(program,
feed=data,
fetch_list=outputs)
iter += 1
if iter % 100 == 0:
print(
'eval iter={}, avg loss {}, acc_top1 {}, acc_top5 {}'.
format(iter, cost, top1, top5))
result[0].append(cost)
result[1].append(top1)
result[2].append(top5)
print(' avg loss {}, acc_top1 {}, acc_top5 {}'.format(
np.mean(result[0]), np.mean(result[1]), np.mean(result[2])))
return np.mean(result[1]), np.mean(result[2])
train(main_prog)
top1_1, top5_1 = test(val_prog)
paddle.fluid.io.save_inference_model(
dirname='./test_quant_post',
feeded_var_names=[image.name, label.name],
target_vars=[avg_cost, acc_top1, acc_top5],
main_program=val_prog,
executor=exe,
model_filename='model',
params_filename='params')
quant_post_static(exe,
'./test_quant_post',
'./test_quant_post_inference',
sample_generator=sample_generator_creator(),
model_filename='model',
params_filename='params',
batch_nums=10)
quant_post_prog, feed_target_names, fetch_targets = paddle.fluid.io.load_inference_model(
dirname='./test_quant_post_inference',
executor=exe,
model_filename='__model__',
params_filename='__params__')
top1_2, top5_2 = test(quant_post_prog, fetch_targets)
print("before quantization: top1: {}, top5: {}".format(top1_1, top5_1))
print("after quantization: top1: {}, top5: {}".format(top1_2, top5_2))
def test_accuracy(self):
image = fluid.layers.data(name='image',
shape=[1, 28, 28],
dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
model = MobileNet()
out = model.net(input=image, class_dim=10)
cost = fluid.layers.cross_entropy(input=out, label=label)
avg_cost = fluid.layers.mean(x=cost)
acc_top1 = fluid.layers.accuracy(input=out, label=label, k=1)
acc_top5 = fluid.layers.accuracy(input=out, label=label, k=5)
optimizer = fluid.optimizer.Momentum(
momentum=0.9,
learning_rate=0.01,
regularization=fluid.regularizer.L2Decay(4e-5))
optimizer.minimize(avg_cost)
main_prog = fluid.default_main_program()
val_prog = main_prog.clone(for_test=True)
place = fluid.CUDAPlace(
0) if fluid.is_compiled_with_cuda() else fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
feeder = fluid.DataFeeder([image, label], place, program=main_prog)
train_reader = paddle.fluid.io.batch(paddle.dataset.mnist.train(),
batch_size=64)
eval_reader = paddle.fluid.io.batch(paddle.dataset.mnist.test(),
batch_size=64)
def train(program):
iter = 0
for data in train_reader():
cost, top1, top5 = exe.run(
program,
feed=feeder.feed(data),
fetch_list=[avg_cost, acc_top1, acc_top5])
iter += 1
if iter % 100 == 0:
print(
'train iter={}, avg loss {}, acc_top1 {}, acc_top5 {}'.
format(iter, cost, top1, top5))
def test(program, outputs=[avg_cost, acc_top1, acc_top5]):
iter = 0
result = [[], [], []]
for data in train_reader():
cost, top1, top5 = exe.run(program,
feed=feeder.feed(data),
fetch_list=outputs)
iter += 1
if iter % 100 == 0:
print(
'eval iter={}, avg loss {}, acc_top1 {}, acc_top5 {}'.
format(iter, cost, top1, top5))
result[0].append(cost)
result[1].append(top1)
result[2].append(top5)
print(' avg loss {}, acc_top1 {}, acc_top5 {}'.format(
np.mean(result[0]), np.mean(result[1]), np.mean(result[2])))
return np.mean(result[1]), np.mean(result[2])
train(main_prog)
top1_1, top5_1 = test(val_prog)
fluid.io.save_inference_model(
dirname='./test_quant_post',
feeded_var_names=[image.name, label.name],
target_vars=[avg_cost, acc_top1, acc_top5],
main_program=val_prog,
executor=exe,
model_filename='model',
params_filename='params')
quant_post_static(exe,
'./test_quant_post',
'./test_quant_post_inference',
sample_generator=paddle.dataset.mnist.test(),
model_filename='model',
params_filename='params',
batch_nums=10)
quant_post_prog, feed_target_names, fetch_targets = fluid.io.load_inference_model(
dirname='./test_quant_post_inference',
executor=exe,
model_filename='__model__',
params_filename='__params__')
top1_2, top5_2 = test(quant_post_prog, fetch_targets)
print("before quantization: top1: {}, top5: {}".format(top1_1, top5_1))
print("after quantization: top1: {}, top5: {}".format(top1_2, top5_2))
def main():
global args
parser = argparse.ArgumentParser(description='PaddlePaddle SlimFaceNet')
parser.add_argument(
'--action', default='train', type=str, help='train/test/quant')
parser.add_argument(
'--model',
default='SlimFaceNet_B_x0_75',
type=str,
help='SlimFaceNet_B_x0_75/SlimFaceNet_C_x0_75/SlimFaceNet_A_x0_60')
parser.add_argument(
'--use_gpu', default=1, type=int, help='Use GPU or not, 0 is not used')
parser.add_argument(
'--lr_strategy',
default='piecewise_decay',
type=str,
help='lr_strategy')
parser.add_argument('--lr', default=0.1, type=float, help='learning rate')
parser.add_argument(
'--lr_list',
default='0.1,0.01,0.001,0.0001',
type=str,
help='learning rate list (piecewise_decay)')
parser.add_argument(
'--lr_steps',
default='36,52,58',
type=str,
help='learning rate decay at which epochs')
parser.add_argument(
'--l2_decay', default=4e-5, type=float, help='base l2_decay')
parser.add_argument(
'--train_data_dir', default='./CASIA', type=str, help='train_data_dir')
parser.add_argument(
'--test_data_dir', default='./lfw', type=str, help='lfw_data_dir')
parser.add_argument(
'--train_batchsize', default=512, type=int, help='train_batchsize')
parser.add_argument(
'--test_batchsize', default=500, type=int, help='test_batchsize')
parser.add_argument(
'--img_shape', default='3,112,96', type=str, help='img_shape')
parser.add_argument(
'--start_epoch', default=0, type=int, help='start_epoch')
parser.add_argument(
'--total_epoch', default=80, type=int, help='total_epoch')
parser.add_argument(
'--save_frequency', default=1, type=int, help='save_frequency')
parser.add_argument(
'--save_ckpt', default='output', type=str, help='save_ckpt')
parser.add_argument(
'--feature_save_dir',
default='result.mat',
type=str,
help='The path of the extract features save, must be .mat file')
args = parser.parse_args()
if args.use_gpu:
num_trainers = fluid.core.get_cuda_device_count()
else:
num_trainers = int(os.environ.get('CPU_NUM', 1))
print(args)
print('num_trainers: {}'.format(num_trainers))
if args.save_ckpt == None:
args.save_ckpt = 'output'
if not os.path.isdir(args.save_ckpt):
os.makedirs(args.save_ckpt)
with open(os.path.join(args.save_ckpt, 'log.txt'), 'w+') as f:
f.writelines(str(args) + '\n')
f.writelines('num_trainers: {}'.format(num_trainers) + '\n')
if args.action == 'train':
train_program = fluid.Program()
test_program = fluid.Program()
startup_program = fluid.Program()
if args.action == 'train':
train_out = build_program(train_program, startup_program, args, True)
test_out = build_program(test_program, startup_program, args, False)
test_program = test_program.clone(for_test=True)
place = fluid.CUDAPlace(0) if args.use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(startup_program)
if args.action == 'train':
train(exe, train_program, train_out, test_program, test_out, args)
elif args.action == 'quant':
quant_post_static(
executor=exe,
model_dir='./out_inference/',
quantize_model_path='./quant_model/',
sample_generator=quant_val_reader_batch(),
model_filename=None, #'model',
params_filename=None, #'params',
save_model_filename=None, #'model',
save_params_filename=None, #'params',
batch_size=np.random.randint(80, 160),
batch_nums=np.random.randint(4, 10))
elif args.action == 'test':
[inference_program, feed_target_names,
fetch_targets] = fluid.io.load_inference_model(
dirname='./quant_model/',
model_filename=None,
params_filename=None,
executor=exe)
nl, nr, flods, flags = parse_filelist(args.test_data_dir)
test_dataset = LFW(nl, nr)
test_reader = fluid.io.batch(
test_dataset.reader,
batch_size=args.test_batchsize,
drop_last=False)
image_test = fluid.data(
name='image_test', shape=[-1, 3, 112, 96], dtype='float32')
image_test1 = fluid.data(
name='image_test1', shape=[-1, 3, 112, 96], dtype='float32')
image_test2 = fluid.data(
name='image_test2', shape=[-1, 3, 112, 96], dtype='float32')
image_test3 = fluid.data(
name='image_test3', shape=[-1, 3, 112, 96], dtype='float32')
image_test4 = fluid.data(
name='image_test4', shape=[-1, 3, 112, 96], dtype='float32')
reader = fluid.io.DataLoader.from_generator(
feed_list=[image_test1, image_test2, image_test3, image_test4],
capacity=64,
iterable=True,
return_list=False)
reader.set_sample_list_generator(
test_reader,
places=fluid.cuda_places() if args.use_gpu else fluid.CPUPlace())
test_out = (fetch_targets, reader, flods, flags)
print('fetch_targets[0]: ', fetch_targets[0])
print('feed_target_names: ', feed_target_names)
test(exe, inference_program, test_out, args)
else:
print('WRONG ACTION')