人工智能专栏推荐

人工智能的分类

弱人工智能（ANI）：特定任务与人类智力或者效率持平

通用人工智能(AGI)：具有人类智力水平，解决通用问题

超人工智能(ASI)：超越人类智力水平，可以在创造力上超越常人

机器学习类型

监督学习：数据集中样本具有标签，比如人脸识别

无监督学习：数据集中样本没有标签，比如文本聚类

增强学习：通过反馈或者惩罚机制学习，比如游戏

人工智能包含机器学习包含深度学习

深度学习框架paddlepaddle

Paddlepaddle框架，要想使用paddle，需要遵循以下几步：

1引用库

2数据预处理

3构造reader

4训练过程

4.1训练场所

4.2网络优化器

4.2.1配置网络结构

4.2.2定义损失函数

4.2.3定义优化器

4.3训练准备

4.3.1定义输入数据与网络的映射关系

4.3.2定义文件路径

4.3.3定义执行器

4.3.4初始化网络参数

4.3.5事件处理函数

4.4模型训练

4.4.1定义reader

4.4.2定义trainer(双层for循环)

4.4.3开始训练

5测试过程

5.1设置预测程序

5.2设置预测器

5.3预测

详细解析

第2步：

数据预处理就是将数据从源文件中读取出来，然后进行一系列操作（归一化，flatten等），将数据分为训练集和测试集两部分

第3步：

def read_data(data_set):

def reader():

for data in data_set:

yield data[:-1],data[-1:]

return reader

第4步

use_cuda = False

place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()

x = fluid.layers.data(name='x', shape=[DATA_DIM], dtype='float32')

x1 = fluid.layers.fc(input=x, size=10, act='relu')

y_predict = fluid.layers.fc(input=x1, size=2, act='softmax')

y = fluid.layers.data(name='y', shape=[1], dtype='int64')

cost = fluid.layers.cross_entropy(input=y_predict, label=y)

avg_loss = fluid.layers.mean(cost)

acc = fluid.layers.accuracy(input=y_predict, label=y)

optimizer = fluid.optimizer.Adam(learning_rate=0.001)

optimizer.minimize(avg_loss)

feeder = fluid.DataFeeder(place=place, feed_list=[x, y])

save_dirname="recognize_cat_inference.model"

exe = fluid.Executor(place)

startup_program = fluid.default_startup_program()

main_program = fluid.default_main_program()#训练模型

exe.run(startup_program)

test_program = fluid.default_main_program().clone(for_test=True)#测试模型

train_prompt = "Train cost"

cost_ploter = Ploter(train_prompt)

# 将训练过程绘图表示

def event_handler_plot(ploter_title, step, cost):

cost_ploter.append(ploter_title, step, cost)

cost_ploter.plot()

def train_test(train_test_program, train_test_feed, train_test_reader):

# 将分类准确率存储在acc_set中

acc_set = []

# 将平均损失存储在avg_loss_set中

avg_loss_set = []

# 将测试 reader yield 出的每一个数据传入网络中进行训练

for test_data in train_test_reader():

acc_np, avg_loss_np = exe.run(

program=train_test_program,

feed=train_test_feed.feed(test_data),

fetch_list=[acc, avg_loss])

acc_set.append(float(acc_np))

avg_loss_set.append(float(avg_loss_np))

# get test acc and loss

# 获得测试数据上的准确率和损失值

acc_val_mean = np.array(acc_set).mean()

avg_loss_val_mean = np.array(avg_loss_set).mean()

# 返回平均损失值，平均准确率

return avg_loss_val_mean, acc_val_mean

BATCH_SIZE=8

# 设置训练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(

read_data(test_set), buf_size=500),

batch_size=BATCH_SIZE)

lists = []

step = 0

for epoch_id in epochs:

for step_id, data in enumerate(train_reader()):

metrics = exe.run(

main_program,

feed=feeder.feed(data),

fetch_list=[avg_loss,acc])

#我们可以把训练结果打印输出，也可以用画图展示出来

if step % 10 == 0: #每训练100次 打印一次log，或者添加一个绘图点

event_handler_plot(train_prompt, step, metrics[0])

step += 1

# test for epoch

# 测试每个epoch的分类效果

avg_loss_val, acc_val = train_test(

train_test_program=test_program,

train_test_reader=test_reader,

train_test_feed=feeder)

print("Test with Epoch %d, avg_cost: %s, acc: %s" %

(epoch_id, avg_loss_val, acc_val))

lists.append((epoch_id, avg_loss_val, acc_val))

# 保存训练好的模型参数用于预测

if save_dirname is not None:

fluid.io.save_inference_model(

save_dirname, ["x"], [y_predict],

exe)

# find the best pass

# 选择效果最好的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))

#指定预测的作用域

inference_scope = fluid.core.Scope()

with fluid.scope_guard(inference_scope):

# 使用 fluid.io.load_inference_model 获取 inference program desc,

# feed_target_names 用于指定需要传入网络的变量名

# fetch_targets 指定希望从网络中fetch出的变量名

[inference_program, feed_target_names,

fetch_targets] = fluid.io.load_inference_model(

save_dirname, exe)

# 将feed构建成字典 {feed_target_name: feed_target_data}

# 结果将包含一个与fetch_targets对应的数据列表

# 我们可以实现批量预测，通过一个循环，每次预测一个mini_batch

for mini_batch in test_reader():

test_x = np.array([data[0] for data in mini_batch]).astype("float32")

test_y = np.array([data[1] for data in mini_batch]).astype("int64")

# 真实进行预测

mini_batch_result = exe.run(

inference_program,

feed={feed_target_names[0]: test_x},

fetch_list=fetch_targets)

# 打印预测结果

print(mini_batch_result)

mini_batch_result = np.argsort(mini_batch_result) #找出可能性最大的列标，升序排列

mini_batch_result = mini_batch_result[0][:, -1] #把这些列标拿出来

print('预测结果：%s'%mini_batch_result)

# 打印真实结果

label = np.array(test_y) # 转化为 label

print('真实结果：%s'%label)

break

训练阶段

metrics = exe.run(

main_program,

feed=feeder.feed(data),

fetch_list=[avg_loss,acc])

main_program表示训练的网络

feed表示输入数据

fetch_list表示将本次训练的avg_loss（平均损失），以及acc(准确率)返回给metrics

运行exe.run表示神经网络完成了一次前向传播、反向传播、以及梯度下降

保存模型

fluid.io.save_inference_model(save_dirname, ["x"], [y_predict],exe)

save_dirname表示模型的保存路径

[“x”]表示模型的输入层

[y_predict]表示模型的预测值

加载模型

[inference_program, feed_target_names,fetch_targets]

= fluid.io.load_inference_model(save_dirname,infer_exe)

其中inferce_program表示模型，也就是神经网络

feed_target_names表示神经网络的输入层

fetch_targets表示神经网络的预测值y_predict

使用模型进行预测

mini_batch_result = exe.run(

inference_program,

feed={feed_target_names[0]: test_x},

fetch_list=fetch_targets)

其中inference_program表示模型

feed表示喂入的数据,然后值为字典{输入层：数据}

fetch_list表示神经网络运行完成之后然后fetch_targets给mini_batch_result，这表示神经网络的预测值