def run_benchmark(model, args): if args.use_cprof: pr = cProfile.Profile() pr.enable() start_time = time.time() word_dict = paddle.dataset.imdb.word_dict() print("load word dict successfully") dict_dim = len(word_dict) data = fluid.layers.data(name="words", shape=[1], dtype="int64", lod_level=1) label = fluid.layers.data(name="label", shape=[1], dtype="int64") prediction = model(data, dict_dim) cost = fluid.layers.cross_entropy(input=prediction, label=label) avg_cost = fluid.layers.mean(x=cost) adam_optimizer = fluid.optimizer.Adam(learning_rate=0.002) adam_optimizer.minimize(avg_cost) accuracy = fluid.evaluator.Accuracy(input=prediction, label=label) train_reader = paddle.batch(paddle.reader.shuffle( paddle.dataset.imdb.train(word_dict), buf_size=25000), batch_size=args.batch_size) place = core.CPUPlace() if args.device == 'CPU' else core.CUDAPlace(0) exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) for it, pass_id in enumerate(xrange(args.pass_num)): accuracy.reset(exe) if iter == args.iterations: break for data in train_reader(): tensor_words = to_lodtensor(map(lambda x: x[0], data), place) label = np.array(map(lambda x: x[1], data)).astype("int64") label = label.reshape([args.batch_size, 1]) tensor_label = fluid.LoDTensor() tensor_label.set(label, place) loss, acc = exe.run(fluid.default_main_program(), feed={ "words": tensor_words, "label": tensor_label }, fetch_list=[avg_cost] + accuracy.metrics) pass_acc = accuracy.eval(exe) print("Iter: %d, loss: %s, acc: %s, pass_acc: %s" % (it, str(loss), str(acc), str(pass_acc)))
def run_benchmark(model, args): if args.use_cprof: pr = cProfile.Profile() pr.enable() start_time = time.time() word_dict = paddle.dataset.imdb.word_dict() print("load word dict successfully") dict_dim = len(word_dict) data = fluid.layers.data(name="words", shape=[args.seq_len * args.batch_size, 1], append_batch_size=False, dtype="int64", lod_level=1) label = fluid.layers.data(name="label", shape=[args.batch_size, 1], append_batch_size=False, dtype="int64") prediction = model(data, dict_dim) cost = fluid.layers.cross_entropy(input=prediction, label=label) avg_cost = fluid.layers.mean(x=cost) adam_optimizer = fluid.optimizer.Adam(learning_rate=0.002) adam_optimizer.minimize(avg_cost) accuracy = fluid.evaluator.Accuracy(input=prediction, label=label) train_reader = paddle.batch( paddle.reader.shuffle(paddle.dataset.imdb.train(word_dict), buf_size=25000), # only for speed batch_size=args.batch_size) place = fluid.CPUPlace() if args.device == 'CPU' else fluid.GPUPlace(0) exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) for it, pass_id in enumerate(xrange(args.pass_num)): accuracy.reset(exe) if it == args.iterations: break for batch_id, data in enumerate(train_reader()): chopped_data = chop_data(data, chop_len=args.seq_len, batch_size=args.batch_size) tensor_words, tensor_label = prepare_feed_data(chopped_data, place) loss, acc = exe.run(fluid.default_main_program(), feed={ "words": tensor_words, "label": tensor_label }, fetch_list=[avg_cost] + accuracy.metrics) pass_acc = accuracy.eval(exe) print("pass=%d, batch=%d, loss=%f, acc=%f, pass_acc=%f" % (it, batch_id, loss, acc, pass_acc))
def run_benchmark(model, args): if args.use_cprof: pr = cProfile.Profile() pr.enable() start_time = time.time() images = fluid.layers.data(name='pixel', shape=[1, 28, 28], dtype=DTYPE) label = fluid.layers.data(name='label', shape=[1], dtype='int64') predict = model(images) cost = fluid.layers.cross_entropy(input=predict, label=label) avg_cost = fluid.layers.mean(x=cost) opt = fluid.optimizer.AdamOptimizer( learning_rate=0.001, beta1=0.9, beta2=0.999) opt.minimize(avg_cost) accuracy = fluid.evaluator.Accuracy(input=predict, label=label) train_reader = paddle.batch( paddle.dataset.mnist.train(), batch_size=args.batch_size) place = fluid.CPUPlace() exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) for pass_id in range(args.pass_num): accuracy.reset(exe) pass_start = time.clock() for batch_id, data in enumerate(train_reader()): img_data = np.array( map(lambda x: x[0].reshape([1, 28, 28]), data)).astype(DTYPE) y_data = np.array(map(lambda x: x[1], data)).astype("int64") y_data = y_data.reshape([len(y_data), 1]) start = time.clock() outs = exe.run(fluid.default_main_program(), feed={"pixel": img_data, "label": y_data}, fetch_list=[avg_cost] + accuracy.metrics) end = time.clock() loss = np.array(outs[0]) acc = np.array(outs[1]) print("pass=%d, batch=%d, loss=%f, error=%f, elapse=%f" % (pass_id, batch_id, loss, 1 - acc, (end - start) / 1000)) pass_end = time.clock() test_avg_acc = eval_test(exe, accuracy, avg_cost) pass_acc = accuracy.eval(exe) print("pass=%d, test_avg_acc=%f, test_avg_acc=%f, elapse=%f" % (pass_id, pass_acc, test_avg_acc, (pass_end - pass_start) / 1000))
def test_nvprof(self): if not fluid.core.is_compile_gpu(): return epoc = 8 dshape = [4, 3, 28, 28] data = layers.data(name='data', shape=[3, 28, 28], dtype='float32') conv = layers.conv2d(data, 20, 3, stride=[1, 1], padding=[1, 1]) place = fluid.GPUPlace(0) exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) with profiler.cuda_profiler("cuda_profiler.txt", 'csv') as nvprof: for i in range(epoc): input = np.random.random(dshape).astype('float32') exe.run(fluid.default_main_program(), feed={'data': input})
def eval_test(exe, accuracy, avg_cost): test_reader = paddle.batch( paddle.dataset.mnist.test(), batch_size=args.batch_size) accuracy.reset(exe) for batch_id, data in enumerate(test_reader()): img_data = np.array(map(lambda x: x[0].reshape([1, 28, 28]), data)).astype(DTYPE) y_data = np.array(map(lambda x: x[1], data)).astype("int64") y_data = y_data.reshape([len(y_data), 1]) exe.run(fluid.default_main_program(), feed={"pixel": img_data, "label": y_data}, fetch_list=[avg_cost] + accuracy.metrics) pass_acc = accuracy.eval(exe) return pass_acc
def main(): BATCH_SIZE = 100 PASS_NUM = 5 word_dict = paddle.dataset.imdb.word_dict() print "load word dict successfully" dict_dim = len(word_dict) class_dim = 2 data = fluid.layers.data(name="words", shape=[1], dtype="int64", lod_level=1) label = fluid.layers.data(name="label", shape=[1], dtype="int64") cost, accuracy, acc_out = stacked_lstm_net(data, label, input_dim=dict_dim, class_dim=class_dim) train_data = paddle.batch(paddle.reader.shuffle( paddle.dataset.imdb.train(word_dict), buf_size=1000), batch_size=BATCH_SIZE) place = fluid.CPUPlace() exe = fluid.Executor(place) feeder = fluid.DataFeeder(feed_list=[data, label], place=place) exe.run(fluid.default_startup_program()) for pass_id in xrange(PASS_NUM): accuracy.reset(exe) for data in train_data(): cost_val, acc_val = exe.run(fluid.default_main_program(), feed=feeder.feed(data), fetch_list=[cost, acc_out]) pass_acc = accuracy.eval(exe) print("cost=" + str(cost_val) + " acc=" + str(acc_val) + " pass_acc=" + str(pass_acc)) if cost_val < 1.0 and acc_val > 0.8: exit(0) exit(1)
def main(): BATCH_SIZE = 100 PASS_NUM = 5 word_dict = paddle.dataset.imdb.word_dict() print "load word dict successfully" dict_dim = len(word_dict) class_dim = 2 data = fluid.layers.data( name="words", shape=[1], dtype="int64", lod_level=1) label = fluid.layers.data(name="label", shape=[1], dtype="int64") cost, accuracy, acc_out = stacked_lstm_net( data, label, input_dim=dict_dim, class_dim=class_dim) train_data = paddle.batch( paddle.reader.shuffle( paddle.dataset.imdb.train(word_dict), buf_size=1000), batch_size=BATCH_SIZE) place = fluid.CPUPlace() exe = fluid.Executor(place) feeder = fluid.DataFeeder(feed_list=[data, label], place=place) exe.run(fluid.default_startup_program()) for pass_id in xrange(PASS_NUM): accuracy.reset(exe) for data in train_data(): cost_val, acc_val = exe.run(fluid.default_main_program(), feed=feeder.feed(data), fetch_list=[cost, acc_out]) pass_acc = accuracy.eval(exe) print("cost=" + str(cost_val) + " acc=" + str(acc_val) + " pass_acc=" + str(pass_acc)) if cost_val < 1.0 and acc_val > 0.8: exit(0) exit(1)
def main(): BATCH_SIZE = 100 PASS_NUM = 5 word_dict = paddle.dataset.imdb.word_dict() print "load word dict successfully" dict_dim = len(word_dict) class_dim = 2 cost, acc = lstm_net(dict_dim=dict_dim, class_dim=class_dim) train_data = paddle.batch(paddle.reader.shuffle( paddle.dataset.imdb.train(word_dict), buf_size=BATCH_SIZE * 10), batch_size=BATCH_SIZE) place = fluid.CPUPlace() exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) for pass_id in xrange(PASS_NUM): for data in train_data(): chopped_data = chop_data(data) tensor_words, tensor_label = prepare_feed_data(chopped_data, place) outs = exe.run(fluid.default_main_program(), feed={ "words": tensor_words, "label": tensor_label }, fetch_list=[cost, acc]) cost_val = np.array(outs[0]) acc_val = np.array(outs[1]) print("cost=" + str(cost_val) + " acc=" + str(acc_val)) if acc_val > 0.7: exit(0) exit(1)
def main(): BATCH_SIZE = 100 PASS_NUM = 5 word_dict = paddle.dataset.imdb.word_dict() print "load word dict successfully" dict_dim = len(word_dict) class_dim = 2 cost, acc = lstm_net(dict_dim=dict_dim, class_dim=class_dim) train_data = paddle.batch( paddle.reader.shuffle( paddle.dataset.imdb.train(word_dict), buf_size=BATCH_SIZE * 10), batch_size=BATCH_SIZE) place = fluid.CPUPlace() exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) for pass_id in xrange(PASS_NUM): for data in train_data(): chopped_data = chop_data(data) tensor_words, tensor_label = prepare_feed_data(chopped_data, place) outs = exe.run(fluid.default_main_program(), feed={"words": tensor_words, "label": tensor_label}, fetch_list=[cost, acc]) cost_val = np.array(outs[0]) acc_val = np.array(outs[1]) print("cost=" + str(cost_val) + " acc=" + str(acc_val)) if acc_val > 0.7: exit(0) exit(1)
cost = fluid.layers.square_error_cost(input=y_predict, label=y) avg_cost = fluid.layers.mean(x=cost) sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.001) sgd_optimizer.minimize(avg_cost) BATCH_SIZE = 20 train_reader = paddle.batch(paddle.reader.shuffle( paddle.dataset.uci_housing.train(), buf_size=500), batch_size=BATCH_SIZE) place = fluid.CPUPlace() feeder = fluid.DataFeeder(place=place, feed_list=[x, y]) exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) PASS_NUM = 100 for pass_id in range(PASS_NUM): fluid.io.save_persistables(exe, "./fit_a_line.model/") fluid.io.load_persistables(exe, "./fit_a_line.model/") for data in train_reader(): avg_loss_value, = exe.run(fluid.default_main_program(), feed=feeder.feed(data), fetch_list=[avg_cost]) if avg_loss_value[0] < 10.0: exit(0) # if avg cost less than 10.0, we think our code is good. exit(1)
predict = fluid.layers.fc(input=hidden2, size=10, act='softmax', param_attr=regularizer) label = fluid.layers.data(name='y', shape=[1], dtype='int64') cost = fluid.layers.cross_entropy(input=predict, label=label) avg_cost = fluid.layers.mean(x=cost) optimizer = fluid.optimizer.Momentum(learning_rate=0.001, momentum=0.9) opts = optimizer.minimize(avg_cost) accuracy = fluid.evaluator.Accuracy(input=predict, label=label) inference_program = fluid.default_main_program().clone() test_accuracy = fluid.evaluator.Accuracy( input=predict, label=label, main_program=inference_program) test_target = [avg_cost] + test_accuracy.metrics + test_accuracy.states inference_program = fluid.io.get_inference_program( test_target, main_program=inference_program) train_reader = paddle.batch( paddle.reader.shuffle( paddle.dataset.mnist.train(), buf_size=8192), batch_size=BATCH_SIZE) test_reader = paddle.batch(paddle.dataset.mnist.test(), batch_size=128) place = fluid.CPUPlace() exe = fluid.Executor(place)
BATCH_SIZE = 128 PASS_NUM = 20 train_reader = paddle.batch( paddle.reader.shuffle( paddle.dataset.cifar.train10(), buf_size=50000), batch_size=BATCH_SIZE) place = fluid.CPUPlace() exe = fluid.Executor(place) feeder = fluid.DataFeeder(place=place, feed_list=[images, label]) exe.run(fluid.default_startup_program()) for pass_id in range(PASS_NUM): accuracy.reset(exe) pass_time = time.time() iterator = 0 for data in train_reader(): loss, acc = exe.run(fluid.default_main_program(), feed=feeder.feed(data), fetch_list=[avg_cost] + accuracy.metrics) pass_acc = accuracy.eval(exe) if iterator % 100 == 0: print("loss:" + str(loss) + " acc:" + str(acc) + " pass_acc:" + str( pass_acc)) # this model is slow, so if we can train two mini batch, we think it works properly. print("pass_id:"+str(pass_id)+" time:"+str(time.time()-pass_time)) # exit(0) #exit(1)
def main(args): """ main """ model_path = args.pretrained_model paddle.init(use_gpu=args.with_gpu) #1, define network topology input_size = cfg.INPUT_SIZE output_size = cfg.INPUT_SIZE / cfg.STRIDE image = fluid.layers.data(name='image', shape=[3, input_size, input_size], dtype='float32') vecmap = fluid.layers.data(name='vecmap', shape=[cfg.VEC_NUM, output_size, output_size], dtype='float32') heatmap = fluid.layers.data( name='heatmap', shape=[cfg.HEATMAP_NUM, output_size, output_size], dtype='float32') vecmask = fluid.layers.data(name='vecmask', shape=[cfg.VEC_NUM, output_size, output_size], dtype='float32') heatmask = fluid.layers.data( name='heatmask', shape=[cfg.HEATMAP_NUM, output_size, output_size], dtype='float32') net = MyNet({'data': image}) vec1 = net.layers['conv5_5_CPM_L1'] heatmap1 = net.layers['conv5_5_CPM_L2'] vec2 = net.layers['Mconv7_stage2_L1'] heatmap2 = net.layers['Mconv7_stage2_L2'] vec3 = net.layers['Mconv7_stage3_L1'] heatmap3 = net.layers['Mconv7_stage3_L2'] vec4 = net.layers['Mconv7_stage4_L1'] heatmap4 = net.layers['Mconv7_stage4_L2'] vec5 = net.layers['Mconv7_stage5_L1'] heatmap5 = net.layers['Mconv7_stage5_L2'] vec6 = net.layers['Mconv7_stage6_L1'] heatmap6 = net.layers['Mconv7_stage6_L2'] loss1_1 = get_mask_loss(vec1, vecmap, vecmask) loss1_2 = get_mask_loss(heatmap1, heatmap, heatmask) loss2_1 = get_mask_loss(vec2, vecmap, vecmask) loss2_2 = get_mask_loss(heatmap2, heatmap, heatmask) loss3_1 = get_mask_loss(vec3, vecmap, vecmask) loss3_2 = get_mask_loss(heatmap3, heatmap, heatmask) loss4_1 = get_mask_loss(vec4, vecmap, vecmask) loss4_2 = get_mask_loss(heatmap4, heatmap, heatmask) loss5_1 = get_mask_loss(vec5, vecmap, vecmask) loss5_2 = get_mask_loss(heatmap5, heatmap, heatmask) loss6_1 = get_mask_loss(vec6, vecmap, vecmask) loss6_2 = get_mask_loss(heatmap6, heatmap, heatmask) loss1 = loss1_1 + loss2_1 + loss3_1 + loss4_1 + loss5_1 + loss6_1 cost1 = fluid.layers.mean(x=loss1) loss2 = loss1_2 + loss2_2 + loss3_2 + loss4_2 + loss5_2 + loss6_2 cost2 = fluid.layers.mean(x=loss2) avg_cost = cost1 + cost2 #avg_cost = fluid.layers.mean(x=cost) model_save_dir = '../models/checkpoints' global_step = layers.create_global_var(shape=[1], value=0.0, dtype='float32', persistable=True, force_cpu=True) lr_rate = lr_decay.piecewise_decay(global_step, values=cfg.LEARNING_RATE_SECTION, boundaries=cfg.BATCH_SECTION) # set learning_rate batch_size num_passes model_save_dir optimizer = fluid.optimizer.Momentum( learning_rate=cfg.LEARNING_RATE, global_step=global_step, momentum=cfg.MOMENTUM, regularization=fluid.regularizer.L2Decay(cfg.WEIGHT_DECAY)) opts = optimizer.minimize(avg_cost) inference_program = fluid.default_main_program().clone() with fluid.program_guard(inference_program): test_target = [avg_cost] inference_program = fluid.io.get_inference_program(test_target) place = fluid.CUDAPlace(3) if args.with_gpu is True else fluid.CPUPlace() exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) train_reader = paddle.batch(CocoFolder.CocoFolder( cfg.TRAIN_DATA_PATH, [ cfg.TRAIN_IMAGELIST_FILE, cfg.TRAIN_MASKLIST_FILE, cfg.TRAIN_KPTJSON_FILE ], cfg.STRIDE, Mytransforms.Compose([ Mytransforms.RandomResized(), Mytransforms.RandomRotate(cfg.RANDOM_ROTATE_ANGLE), Mytransforms.RandomCrop(cfg.INPUT_SIZE), Mytransforms.RandomHorizontalFlip(), ])).reader, batch_size=cfg.BATCH_SIZE) feeder = fluid.DataFeeder( place=place, feed_list=[image, vecmap, heatmap, vecmask, heatmask]) if not model_path: pass elif model_path.find('.npy') > 0: net.load(data_path=model_path, exe=exe, place=place) else: net.load(data_path=model_path, exe=exe) for pass_id in range(cfg.NUM_PASSES): for batch_id, data in enumerate(train_reader()): loss, step_v, lr_rate_v = exe.run(fluid.default_main_program(), feed=feeder.feed(data), fetch_list=[avg_cost] + [global_step] + [lr_rate]) print("Pass {0}, batch {1}, loss {2}, step {3}, lr{4}".format( pass_id, batch_id, loss[0], step_v[0], lr_rate_v[0])) if batch_id % 3000 == 0: model_path = os.path.join(model_save_dir, 'batch' + str(batch_id)) print 'save models to %s' % (model_path) fluid.io.save_inference_model(model_path, ['image'], [vec6, heatmap6], exe) ''' test loss needed for data in test_reader(): loss = exe.run(inference_program, feed=feeder.feed(data), fetch_list=[avg_cost]) ''' print("End pass {0}".format(pass_id)) if pass_id % 1 == 0: model_path = os.path.join(model_save_dir, 'pass' + str(pass_id)) print 'save models to %s' % (model_path) fluid.io.save_inference_model(model_path, ['image'], [vec6, heatmap6], exe)
avg_cost = fluid.layers.mean(x=cost) sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.001) sgd_optimizer.minimize(avg_cost) BATCH_SIZE = 20 train_reader = paddle.batch( paddle.reader.shuffle( paddle.dataset.uci_housing.train(), buf_size=500), batch_size=BATCH_SIZE) place = fluid.CPUPlace() feeder = fluid.DataFeeder(place=place, feed_list=[x, y]) exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) PASS_NUM = 100 for pass_id in range(PASS_NUM): fluid.io.save_persistables(exe, "./fit_a_line.model/") fluid.io.load_persistables(exe, "./fit_a_line.model/") for data in train_reader(): avg_loss_value, = exe.run(fluid.default_main_program(), feed=feeder.feed(data), fetch_list=[avg_cost]) if avg_loss_value[0] < 10.0: exit(0) # if avg cost less than 10.0, we think our code is good. exit(1)
def main(): if args.data_set == "cifar10": classdim = 10 if args.data_format == 'NCHW': data_shape = [3, 32, 32] else: data_shape = [32, 32, 3] else: classdim = 102 if args.data_format == 'NCHW': data_shape = [3, 224, 224] else: data_shape = [224, 224, 3] # Input data images = fluid.layers.data(name='pixel', shape=data_shape, dtype='float32') label = fluid.layers.data(name='label', shape=[1], dtype='int64') # Train program net = vgg16_bn_drop(images) predict = fluid.layers.fc(input=net, size=classdim, act='softmax') cost = fluid.layers.cross_entropy(input=predict, label=label) avg_cost = fluid.layers.mean(x=cost) # Evaluator accuracy = fluid.evaluator.Accuracy(input=predict, label=label) # inference program inference_program = fluid.default_main_program().clone() with fluid.program_guard(inference_program): test_target = accuracy.metrics + accuracy.states inference_program = fluid.io.get_inference_program(test_target) # Optimization optimizer = fluid.optimizer.Adam(learning_rate=args.learning_rate) opts = optimizer.minimize(avg_cost) fluid.memory_optimize(fluid.default_main_program()) # Initialize executor place = core.CPUPlace() if args.device == 'CPU' else core.CUDAPlace(0) exe = fluid.Executor(place) # Parameter initialization exe.run(fluid.default_startup_program()) # data reader train_reader = paddle.batch( paddle.reader.shuffle( paddle.dataset.cifar.train10() if args.data_set == 'cifar10' else paddle.dataset.flowers.train(), buf_size=5120), batch_size=args.batch_size) test_reader = paddle.batch( paddle.dataset.cifar.test10() if args.data_set == 'cifar10' else paddle.dataset.flowers.test(), batch_size=args.batch_size) # test def test(exe): accuracy.reset(exe) for batch_id, data in enumerate(test_reader()): img_data = np.array(map(lambda x: x[0].reshape(data_shape), data)).astype("float32") y_data = np.array(map(lambda x: x[1], data)).astype("int64") y_data = y_data.reshape([-1, 1]) exe.run(inference_program, feed={"pixel": img_data, "label": y_data}) return accuracy.eval(exe) iters = 0 for pass_id in range(args.num_passes): # train start_time = time.time() num_samples = 0 accuracy.reset(exe) for batch_id, data in enumerate(train_reader()): img_data = np.array(map(lambda x: x[0].reshape(data_shape), data)).astype("float32") y_data = np.array(map(lambda x: x[1], data)).astype("int64") y_data = y_data.reshape([-1, 1]) loss, acc = exe.run(fluid.default_main_program(), feed={"pixel": img_data, "label": y_data}, fetch_list=[avg_cost] + accuracy.metrics) iters += 1 num_samples += len(data) print( "Pass = %d, Iters = %d, Loss = %f, Accuracy = %f" % (pass_id, iters, loss, acc) ) # The accuracy is the accumulation of batches, but not the current batch. pass_elapsed = time.time() - start_time pass_train_acc = accuracy.eval(exe) pass_test_acc = test(exe) print( "Pass = %d, Training performance = %f imgs/s, Train accuracy = %f, Test accuracy = %f\n" % (pass_id, num_samples / pass_elapsed, pass_train_acc, pass_test_acc))
param_attr='shared_w') concat_embed = fluid.layers.concat( input=[embed_first, embed_second, embed_third, embed_forth], axis=1) hidden1 = fluid.layers.fc(input=concat_embed, size=HIDDEN_SIZE, act='sigmoid') predict_word = fluid.layers.fc(input=hidden1, size=dict_size, act='softmax') cost = fluid.layers.cross_entropy(input=predict_word, label=next_word) avg_cost = fluid.layers.mean(x=cost) sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.001) sgd_optimizer.minimize(avg_cost) train_reader = paddle.batch( paddle.dataset.imikolov.train(word_dict, N), BATCH_SIZE) place = fluid.CPUPlace() exe = fluid.Executor(place) feeder = fluid.DataFeeder( feed_list=[first_word, second_word, third_word, forth_word, next_word], place=place) exe.run(fluid.default_startup_program()) for pass_id in range(PASS_NUM): for data in train_reader(): avg_cost_np = exe.run(fluid.default_main_program(), feed=feeder.feed(data), fetch_list=[avg_cost]) if avg_cost_np[0] < 5.0: exit(0) # if avg cost less than 10.0, we think our code is good. exit(1)
sgd_optimizer.minimize(avg_cost) BATCH_SIZE = 20 train_reader = paddle.batch( paddle.reader.shuffle( paddle.dataset.uci_housing.train(), buf_size=500), batch_size=BATCH_SIZE) place = fluid.CPUPlace() exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) # Print computation graph train_fw.write_graph(pbu.convert_program_to_tf_graph_def(fluid.default_main_program())) PASS_NUM = 100 batch_id = 0 for pass_id in range(PASS_NUM): fluid.io.save_persistables(exe, "./fit_a_line.model/") fluid.io.load_persistables(exe, "./fit_a_line.model/") for data in train_reader(): x_data = np.array(map(lambda _: _[0], data)).astype("float32") y_data = np.array(map(lambda _: _[1], data)).astype("float32") avg_loss_value, = exe.run(fluid.default_main_program(), feed={'x': x_data, 'y': y_data}, fetch_list=[avg_cost])
predict_word = fluid.layers.fc(input=hidden1_drop, size=dict_size, act='softmax', param_attr=predict_param_attr, bias_attr=predict_bias_attr) cost = fluid.layers.cross_entropy(input=predict_word, label=next_word) avg_cost = fluid.layers.mean(x=cost) avg_cost = fluid.layers.scale(x=avg_cost, scale=float(BATCH_SIZE)) optimizer = Adagrad(learning_rate=3e-3) optimizer.minimize(avg_cost) accuracy = fluid.evaluator.Accuracy(input=predict_word, label=next_word) inference_program = fluid.default_main_program().clone() test_accuracy = fluid.evaluator.Accuracy(input=predict_word, label=next_word, main_program=inference_program) test_target = [avg_cost] + test_accuracy.metrics + test_accuracy.states inference_program = fluid.io.get_inference_program( test_target, main_program=inference_program) train_reader = paddle.batch(paddle.dataset.imikolov.train(word_dict, N), BATCH_SIZE) test_reader = paddle.batch(paddle.dataset.imikolov.test(word_dict, N), BATCH_SIZE) place = fluid.GPUPlace(0) exe = fluid.Executor(place) feeder = fluid.DataFeeder(
accuracy = fluid.evaluator.Accuracy(input=predict, label=label) BATCH_SIZE = 50 PASS_NUM = 3 train_reader = paddle.batch(paddle.reader.shuffle(paddle.dataset.mnist.train(), buf_size=500), batch_size=BATCH_SIZE) place = fluid.CPUPlace() exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) # Print computation graph train_fw.write_graph( pbu.convert_program_to_tf_graph_def(fluid.default_main_program())) batch_id = 0 for pass_id in range(PASS_NUM): accuracy.reset(exe) for data in train_reader(): img_data = np.array(map(lambda x: x[0].reshape([1, 28, 28]), data)).astype("float32") y_data = np.array(map(lambda x: x[1], data)).astype("int64") y_data = y_data.reshape([BATCH_SIZE, 1]) loss, acc = exe.run(fluid.default_main_program(), feed={ "pixel": img_data, "label": y_data
param_attr='shared_w') concat_embed = fluid.layers.concat( input=[embed_first, embed_second, embed_third, embed_forth], axis=1) hidden1 = fluid.layers.fc(input=concat_embed, size=HIDDEN_SIZE, act='sigmoid') predict_word = fluid.layers.fc(input=hidden1, size=dict_size, act='softmax') cost = fluid.layers.cross_entropy(input=predict_word, label=next_word) avg_cost = fluid.layers.mean(x=cost) sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.001) sgd_optimizer.minimize(avg_cost) train_reader = paddle.batch(paddle.dataset.imikolov.train(word_dict, N), BATCH_SIZE) place = fluid.CPUPlace() exe = fluid.Executor(place) feeder = fluid.DataFeeder( feed_list=[first_word, second_word, third_word, forth_word, next_word], place=place) exe.run(fluid.default_startup_program()) for pass_id in range(PASS_NUM): for data in train_reader(): avg_cost_np = exe.run(fluid.default_main_program(), feed=feeder.feed(data), fetch_list=[avg_cost]) if avg_cost_np[0] < 5.0: exit(0) # if avg cost less than 10.0, we think our code is good. exit(1)
def main(dict_path): word_dict = load_vocab(dict_path) word_dict["<unk>"] = len(word_dict) dict_dim = len(word_dict) print("The dictionary size is : %d" % dict_dim) data, label, prediction, avg_cost = conv_net(dict_dim) sgd_optimizer = fluid.optimizer.SGD(learning_rate=conf.learning_rate) sgd_optimizer.minimize(avg_cost) accuracy = fluid.evaluator.Accuracy(input=prediction, label=label) inference_program = fluid.default_main_program().clone() with fluid.program_guard(inference_program): test_target = accuracy.metrics + accuracy.states inference_program = fluid.io.get_inference_program(test_target) # The training data set. train_reader = paddle.batch( paddle.reader.shuffle( paddle.dataset.imdb.train(word_dict), buf_size=51200), batch_size=conf.batch_size) # The testing data set. test_reader = paddle.batch( paddle.reader.shuffle( paddle.dataset.imdb.test(word_dict), buf_size=51200), batch_size=conf.batch_size) if conf.use_gpu: place = fluid.CUDAPlace(0) else: place = fluid.CPUPlace() exe = fluid.Executor(place) feeder = fluid.DataFeeder(feed_list=[data, label], place=place) exe.run(fluid.default_startup_program()) def test(exe): accuracy.reset(exe) for batch_id, data in enumerate(test_reader()): input_seq = to_lodtensor(map(lambda x: x[0], data), place) y_data = np.array(map(lambda x: x[1], data)).astype("int64") y_data = y_data.reshape([-1, 1]) acc = exe.run(inference_program, feed={"words": input_seq, "label": y_data}) test_acc = accuracy.eval(exe) return test_acc total_time = 0. for pass_id in xrange(conf.num_passes): accuracy.reset(exe) start_time = time.time() for batch_id, data in enumerate(train_reader()): cost_val, acc_val = exe.run( fluid.default_main_program(), feed=feeder.feed(data), fetch_list=[avg_cost, accuracy.metrics[0]]) pass_acc = accuracy.eval(exe) if batch_id and batch_id % conf.log_period == 0: print("Pass id: %d, batch id: %d, cost: %f, pass_acc %f" % (pass_id, batch_id, cost_val, pass_acc)) end_time = time.time() total_time += (end_time - start_time) pass_test_acc = test(exe) print("Pass id: %d, test_acc: %f" % (pass_id, pass_test_acc)) print("Total train time: %f" % (total_time))
exe = fluid.Executor(place) feeder = fluid.DataFeeder(place=place, feed_list=[images, label]) exe.run(fluid.default_startup_program()) step = 0 sample_num = 0 start_up_program = framework.default_startup_program() param1_var = start_up_program.global_block().var("param1") for pass_id in range(PASS_NUM): accuracy.reset(exe) for data in train_reader(): loss, conv1_out, param1, acc = exe.run( fluid.default_main_program(), feed=feeder.feed(data), fetch_list=[avg_cost, conv1, param1_var] + accuracy.metrics) pass_acc = accuracy.eval(exe) # all code below is for VisualDL # start picking sample from beginning if sample_num == 0: input_image.start_sampling() conv_image.start_sampling() idx1 = input_image.is_sample_taken() idx2 = conv_image.is_sample_taken() assert idx1 == idx2 idx = idx1
BATCH_SIZE = 50 PASS_NUM = 3 train_reader = paddle.batch( paddle.reader.shuffle( paddle.dataset.mnist.train(), buf_size=500), batch_size=BATCH_SIZE) place = fluid.CPUPlace() exe = fluid.Executor(place) feeder = fluid.DataFeeder(feed_list=[images, label], place=place) exe.run(fluid.default_startup_program()) for pass_id in range(PASS_NUM): accuracy.reset(exe) for data in train_reader(): loss, acc = exe.run(fluid.default_main_program(), feed=feeder.feed(data), fetch_list=[avg_cost] + accuracy.metrics) pass_acc = accuracy.eval(exe) print("pass_id=" + str(pass_id) + " acc=" + str(acc) + " pass_acc=" + str(pass_acc)) # print loss, acc if loss < 10.0 and pass_acc > 0.9: # if avg cost less than 10.0 and accuracy is larger than 0.9, we think our code is good. exit(0) pass_acc = accuracy.eval(exe) print("pass_id=" + str(pass_id) + " pass_acc=" + str(pass_acc)) exit(1)
predict_word = fluid.layers.fc(input=hidden1_drop, size=dict_size, act='softmax', param_attr=predict_param_attr, bias_attr=predict_bias_attr) cost = fluid.layers.cross_entropy(input=predict_word, label=next_word) avg_cost = fluid.layers.mean(x=cost) avg_cost = fluid.layers.scale(x=avg_cost, scale=float(BATCH_SIZE)) optimizer = Adagrad(learning_rate=3e-3) optimizer.minimize(avg_cost) accuracy = fluid.evaluator.Accuracy(input=predict_word, label=next_word) inference_program = fluid.default_main_program().clone() test_accuracy = fluid.evaluator.Accuracy(input=predict_word, label=next_word, main_program=inference_program) test_target = [avg_cost] + test_accuracy.metrics + test_accuracy.states inference_program = fluid.io.get_inference_program( test_target, main_program=inference_program) train_reader = paddle.batch(paddle.dataset.imikolov.train(word_dict, N), BATCH_SIZE) test_reader = paddle.batch(paddle.dataset.imikolov.test(word_dict, N), BATCH_SIZE) place = fluid.GPUPlace(0) exe = fluid.Executor(place) feeder = fluid.DataFeeder(
def run_benchmark(model, args): if args.use_cprof: pr = cProfile.Profile() pr.enable() start_time = time.time() class_dim = 102 dshape = [3, 224, 224] if args.order == 'NCHW' else [224, 224, 3] input = fluid.layers.data(name='data', shape=dshape, dtype='float32') label = fluid.layers.data(name='label', shape=[1], dtype='int64') predict = model(input, class_dim) cost = fluid.layers.cross_entropy(input=predict, label=label) avg_cost = fluid.layers.mean(x=cost) optimizer = fluid.optimizer.Momentum(learning_rate=0.01, momentum=0.9) opts = optimizer.minimize(avg_cost) accuracy = fluid.evaluator.Accuracy(input=predict, label=label) train_reader = paddle.batch(paddle.reader.shuffle( paddle.dataset.flowers.train(), buf_size=5120), batch_size=args.batch_size) place = fluid.CPUPlace() if args.device == 'CPU' else fluid.GPUPlace(0) exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) iter = 0 for pass_id in range(args.pass_num): accuracy.reset(exe) if iter == args.iterations: break for data in train_reader(): if iter == args.iterations: break image = np.array(map(lambda x: x[0].reshape(dshape), data)).astype('float32') label = np.array(map(lambda x: x[1], data)).astype('int64') label = label.reshape([-1, 1]) loss, acc = exe.run(fluid.default_main_program(), feed={ 'data': image, 'label': label }, fetch_list=[avg_cost] + accuracy.metrics) pass_acc = accuracy.eval(exe) print("Iter: %d, loss: %s, acc: %s, pass_acc: %s" % (iter, str(loss), str(acc), str(pass_acc))) iter += 1 duration = time.time() - start_time examples_per_sec = args.iterations * args.batch_size / duration sec_per_batch = duration / args.batch_size print('\nTotal examples: %d, total time: %.5f' % (args.iterations * args.batch_size, duration)) print('%.5f examples/sec, %.5f sec/batch \n' % (examples_per_sec, sec_per_batch)) if args.use_cprof: pr.disable() s = StringIO.StringIO() sortby = 'cumulative' ps = pstats.Stats(pr, stream=s).sort_stats(sortby) ps.print_stats() print(s.getvalue())
def main(): # define network topology word = fluid.layers.data( name='word_data', shape=[1], dtype='int64', lod_level=1) predicate = fluid.layers.data( name='verb_data', shape=[1], dtype='int64', lod_level=1) ctx_n2 = fluid.layers.data( name='ctx_n2_data', shape=[1], dtype='int64', lod_level=1) ctx_n1 = fluid.layers.data( name='ctx_n1_data', shape=[1], dtype='int64', lod_level=1) ctx_0 = fluid.layers.data( name='ctx_0_data', shape=[1], dtype='int64', lod_level=1) ctx_p1 = fluid.layers.data( name='ctx_p1_data', shape=[1], dtype='int64', lod_level=1) ctx_p2 = fluid.layers.data( name='ctx_p2_data', shape=[1], dtype='int64', lod_level=1) mark = fluid.layers.data( name='mark_data', shape=[1], dtype='int64', lod_level=1) feature_out = db_lstm(**locals()) target = fluid.layers.data( name='target', shape=[1], dtype='int64', lod_level=1) crf_cost = fluid.layers.linear_chain_crf( input=feature_out, label=target, param_attr=fluid.ParamAttr( name='crfw', learning_rate=mix_hidden_lr)) avg_cost = fluid.layers.mean(x=crf_cost) # TODO(qiao) # check other optimizers and check why out will be NAN sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.0001) sgd_optimizer.minimize(avg_cost) # TODO(qiao) # add dependency track and move this config before optimizer crf_decode = fluid.layers.crf_decoding( input=feature_out, param_attr=fluid.ParamAttr(name='crfw')) precision, recall, f1_score = fluid.layers.chunk_eval( input=crf_decode, label=target, chunk_scheme="IOB", num_chunk_types=int(math.ceil((label_dict_len - 1) / 2.0))) train_data = paddle.batch( paddle.reader.shuffle( paddle.dataset.conll05.test(), buf_size=8192), batch_size=BATCH_SIZE) place = fluid.CPUPlace() feeder = fluid.DataFeeder( feed_list=[ word, ctx_n2, ctx_n1, ctx_0, ctx_p1, ctx_p2, predicate, mark, target ], place=place) exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) embedding_param = fluid.g_scope.find_var(embedding_name).get_tensor() embedding_param.set( load_parameter(conll05.get_embedding(), word_dict_len, word_dim), place) batch_id = 0 for pass_id in xrange(PASS_NUM): for data in train_data(): outs = exe.run(fluid.default_main_program(), feed=feeder.feed(data), fetch_list=[avg_cost, precision, recall, f1_score]) avg_cost_val = np.array(outs[0]) precision_val = np.array(outs[1]) recall_val = np.array(outs[2]) f1_score_val = np.array(outs[3]) if batch_id % 10 == 0: print("avg_cost=" + str(avg_cost_val)) print("precision_val=" + str(precision_val)) print("recall_val:" + str(recall_val)) print("f1_score_val:" + str(f1_score_val)) # exit early for CI exit(0) batch_id = batch_id + 1
def main(): # define network topology word = fluid.layers.data(name='word_data', shape=[1], dtype='int64', lod_level=1) predicate = fluid.layers.data(name='verb_data', shape=[1], dtype='int64', lod_level=1) ctx_n2 = fluid.layers.data(name='ctx_n2_data', shape=[1], dtype='int64', lod_level=1) ctx_n1 = fluid.layers.data(name='ctx_n1_data', shape=[1], dtype='int64', lod_level=1) ctx_0 = fluid.layers.data(name='ctx_0_data', shape=[1], dtype='int64', lod_level=1) ctx_p1 = fluid.layers.data(name='ctx_p1_data', shape=[1], dtype='int64', lod_level=1) ctx_p2 = fluid.layers.data(name='ctx_p2_data', shape=[1], dtype='int64', lod_level=1) mark = fluid.layers.data(name='mark_data', shape=[1], dtype='int64', lod_level=1) feature_out = db_lstm(**locals()) target = fluid.layers.data(name='target', shape=[1], dtype='int64', lod_level=1) crf_cost = fluid.layers.linear_chain_crf(input=feature_out, label=target, param_attr=fluid.ParamAttr( name='crfw', learning_rate=mix_hidden_lr)) avg_cost = fluid.layers.mean(x=crf_cost) # TODO(qiao) # check other optimizers and check why out will be NAN sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.0001) sgd_optimizer.minimize(avg_cost) # TODO(qiao) # add dependency track and move this config before optimizer crf_decode = fluid.layers.crf_decoding( input=feature_out, param_attr=fluid.ParamAttr(name='crfw')) precision, recall, f1_score = fluid.layers.chunk_eval( input=crf_decode, label=target, chunk_scheme="IOB", num_chunk_types=int(math.ceil((label_dict_len - 1) / 2.0))) train_data = paddle.batch(paddle.reader.shuffle( paddle.dataset.conll05.test(), buf_size=8192), batch_size=BATCH_SIZE) place = fluid.CPUPlace() feeder = fluid.DataFeeder(feed_list=[ word, ctx_n2, ctx_n1, ctx_0, ctx_p1, ctx_p2, predicate, mark, target ], place=place) exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) embedding_param = fluid.g_scope.find_var(embedding_name).get_tensor() embedding_param.set( load_parameter(conll05.get_embedding(), word_dict_len, word_dim), place) batch_id = 0 for pass_id in xrange(PASS_NUM): for data in train_data(): outs = exe.run(fluid.default_main_program(), feed=feeder.feed(data), fetch_list=[avg_cost, precision, recall, f1_score]) avg_cost_val = np.array(outs[0]) precision_val = np.array(outs[1]) recall_val = np.array(outs[2]) f1_score_val = np.array(outs[3]) if batch_id % 10 == 0: print("avg_cost=" + str(avg_cost_val)) print("precision_val=" + str(precision_val)) print("recall_val:" + str(recall_val)) print("f1_score_val:" + str(f1_score_val)) # exit early for CI exit(0) batch_id = batch_id + 1
def run_benchmark(model, args): if args.use_cprof: pr = cProfile.Profile() pr.enable() start_time = time.time() # Input data images = fluid.layers.data(name='pixel', shape=[1, 28, 28], dtype=DTYPE) label = fluid.layers.data(name='label', shape=[1], dtype='int64') # Train program predict = model(images) cost = fluid.layers.cross_entropy(input=predict, label=label) avg_cost = fluid.layers.mean(x=cost) # Evaluator accuracy = fluid.evaluator.Accuracy(input=predict, label=label) # inference program inference_program = fluid.default_main_program().clone() with fluid.program_guard(inference_program): test_target = accuracy.metrics + accuracy.states inference_program = fluid.io.get_inference_program(test_target) # Optimization opt = fluid.optimizer.AdamOptimizer(learning_rate=0.001, beta1=0.9, beta2=0.999) opt.minimize(avg_cost) fluid.memory_optimize(fluid.default_main_program()) # Initialize executor place = fluid.CPUPlace() if args.device == 'CPU' else fluid.CUDAPlace(0) exe = fluid.Executor(place) # Parameter initialization exe.run(fluid.default_startup_program()) # Reader train_reader = paddle.batch(paddle.dataset.mnist.train(), batch_size=args.batch_size) for pass_id in range(args.pass_num): accuracy.reset(exe) pass_start = time.time() for batch_id, data in enumerate(train_reader()): img_data = np.array(map(lambda x: x[0].reshape([1, 28, 28]), data)).astype(DTYPE) y_data = np.array(map(lambda x: x[1], data)).astype("int64") y_data = y_data.reshape([len(y_data), 1]) start = time.time() outs = exe.run( fluid.default_main_program(), feed={ "pixel": img_data, "label": y_data }, fetch_list=[avg_cost] + accuracy.metrics ) # The accuracy is the accumulation of batches, but not the current batch. end = time.time() loss = np.array(outs[0]) acc = np.array(outs[1]) print("pass=%d, batch=%d, loss=%f, error=%f, elapse=%f" % (pass_id, batch_id, loss, 1 - acc, (end - start) / 1000)) pass_end = time.time() train_avg_acc = accuracy.eval(exe) test_avg_acc = eval_test(exe, accuracy, inference_program) print("pass=%d, train_avg_acc=%f, test_avg_acc=%f, elapse=%f" % (pass_id, train_avg_acc, test_avg_acc, (pass_end - pass_start) / 1000))