import paddle.fluid as fluid
# 定义常量x1、指定形状[2,2],并赋值1，指定类型 int64
x1 = fluid.layers.fill_constant(shape = [2,2], value = 1 ,dtype = 'int64')
x2 = fluid.layers.fill_constant(shape=[2, 2], value=1, dtype='int64')
# 定义两个张量（动态的）
a = fluid.layers.create_tensor(dtype='int64', name='a')
b = fluid.layers.create_tensor(dtype='int64', name='b')
# 两个常量、张量求和（paddle 中的计算都可以在 fluid.layers 中找到）
y1 = fluid.layers.sum(x=[x1, x2]) # x = [a,b]
# 创建解释器（定义程序运行在CPU 或GPU上）
place = fluid.CPUPlace()
exe = fluid.executor.Executor(place)
# 参数初始化(exe.run 中含program参数、feed （对张量以字典形式进行赋值）、fetch_list 参数（程序执行后输出的值，为一张量））
exe.run(fluid.default_startup_program())
result = exe.run(program=fluid.default_main_program(),fetch_list=[y1])
out_a, out_b, result = exe.run(program=fluid.default_main_program(),
feed={'a': a1, 'b': b1},
fetch_list=[a, b, y])
# 定义简单的线性网络
x = fluid.layers.data(name = 'x',shape = [13],dtype = 'float32')
hidden = fluid,layers.fc (input = x ,size = 100 ,act = 'relu') # 输出神经元数（通道），act 激活函数
net = fluid.layers.fc(input=hidden, size=1, act=None)
#定义损失函数
y = fluid.layers.data(name='y', shape=[1], dtype='float32')
cost = fluid.layers.square_error_cost(input=net, label=y) # square_error_cost 平方差损失函数
avg_cost = fluid.layers.mean(cost) # 平均数
# 复制一个主程序，方便之后使用
test_program = fluid.default_main_program().clone(for_test=True)
# 定义优化方法
optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.01) # 优化方法实例化、fluid.optimizer.[优化方法名称]
opts = optimizer.minimize(avg_cost) # 实例化优化方法后，取平均数最小点
# 开始训练100个pass
for pass_id in range(10):
train_cost = exe.run(program=fluid.default_main_program(),
feed={'x': x_data, 'y': y_data},
fetch_list=[avg_cost])
print("Pass:%d, Cost:%0.5f" % (pass_id, train_cost[0]))
# 开始预测
result = exe.run(program=test_program,
feed={'x': test_data, 'y': np.array([[0.0]]).astype('float32')},
fetch_list=[net])
print("当x为6.0时，y为：%0.5f" % result[0][0][0])
paddle.batch("数据集"，batch_size = 100) # 数据集读取后，分成 batch_size 大小的小份
paddle.reader.shuffle("数据集"，buf_size = 100) # 随机读取buf_size 大小的数据
train_reader = paddle.batch(
paddle.reader.shuffle(paddle.dataset.uci_housing.train(),
buf_size=BUF_SIZE),
batch_size=BATCH_SIZE)
#读取数据集
paddle.dataset.["数据集名称"]
#DataFeeder负责将数据提供器（train_reader,test_reader）返回的数据转成一种特殊的数据结构，使其可以输入到Executor中。
#feed_list设置向模型输入的向变量表或者变量表名
# 定义输入数据维度
feeder = fluid.DataFeeder(place=place, feed_list=[x, y])#feed_list:向模型输入的变量表或变量表名
#定义绘制训练过程的损失值变化趋势的方法draw_train_process
iter=0;
iters=[]
train_costs=[]
def draw_train_process(iters,train_costs):
title="training cost"
plt.title(title, fontsize=24)
plt.xlabel("iter", fontsize=14)
plt.ylabel("cost", fontsize=14)
plt.plot(iters, train_costs,color='red',label='training cost')
plt.grid()
plt.show()
EPOCH_NUM=50
model_save_dir = "/home/aistudio/work/fit_a_line.inference.model"
for pass_id in range(EPOCH_NUM): #训练EPOCH_NUM轮
# 开始训练并输出最后一个batch的损失值
train_cost = 0
for batch_id, data in enumerate(train_reader()): #遍历train_reader迭代器
train_cost = exe.run(program=fluid.default_main_program(),#运行主程序
feed=feeder.feed(data), #喂入一个batch的训练数据，根据feed_list和data提供的信息，将输入数据转成一种特殊的数据结构
fetch_list=[avg_cost])
if batch_id % 40 == 0:
print("Pass:%d, Cost:%0.5f" % (pass_id, train_cost[0][0])) #打印最后一个batch的损失值
iter=iter+BATCH_SIZE
iters.append(iter)
train_costs.append(train_cost[0][0])
# 开始测试并输出最后一个batch的损失值
test_cost = 0
for batch_id, data in enumerate(test_reader()): #遍历test_reader迭代器
test_cost= exe.run(program=test_program, #运行测试cheng
feed=feeder.feed(data), #喂入一个batch的测试数据
fetch_list=[avg_cost]) #fetch均方误差
print('Test:%d, Cost:%0.5f' % (pass_id, test_cost[0][0])) #打印最后一个batch的损失值
#保存模型
# 如果保存路径不存在就创建
if not os.path.exists(model_save_dir):
os.makedirs(model_save_dir)
print ('save models to %s' % (model_save_dir))
#保存训练参数到指定路径中，构建一个专门用预测的program
fluid.io.save_inference_model(model_save_dir, #保存推理model的路径
['x'], #推理（inference）需要 feed 的数据
[y_predict], #保存推理（inference）结果的 Variables
exe) #exe 保存 inference model
draw_train_process(iters,train_costs)
Predicción del modelo
# 常见预测用Executor
infer_exe = fluid.Executor(place) #创建推测用的executor
inference_scope = fluid.core.Scope() #Scope指定作用域
#开始预测
with fluid.scope_guard(inference_scope):#修改全局/默认作用域（scope）, 运行时中的所有变量都将分配给新的scope。
#从指定目录中加载 推理model(inference model)
[inference_program, #推理的program
feed_target_names, #需要在推理program中提供数据的变量名称
fetch_targets] = #fetch_targets: 推断结果
fluid.io.load_inference_model(
model_save_dir, #model_save_dir:模型训练路径
infer_exe) #infer_exe: 预测用executor
#获取预测数据
infer_reader = paddle.batch(paddle.dataset.uci_housing.test(), #获取uci_housing的测试数据
batch_size=200) #从测试数据中读取一个大小为200的batch数据
#从test_reader中分割x
test_data = next(infer_reader())
test_x = np.array([data[0] for data in test_data]).astype("float32")
test_y= np.array([data[1] for data in test_data]).astype("float32")
results = infer_exe.run(inference_program, #预测模型
feed={feed_target_names[0]: np.array(test_x)}, #喂入要预测的x值
fetch_list=fetch_targets) #得到推测结果
print("infer results: (House Price)")
for idx, val in enumerate(results[0]):
print("%d: %.2f" % (idx, val))
infer_results.append(val)
print("ground truth:")
for idx, val in enumerate(test_y):
print("%d: %.2f" % (idx, val))
groud_truths.append(val)
draw_infer_result(groud_truths,infer_results)
