12月25日作业

作业5-1：

分类准确率为：0.97

作业5-2：

1、全连接神经网络(FNN)

2、卷积神经网络（CNN）

3、循环神经网络(RNN)

作业5-3：

用Adam算法在学习率为0.005最优

作业5-1：

# 验证集验证
def eval():
print('start evaluation .......')
# 加载模型参数
model = MNIST("mnist")
model_state_dict, _ = fluid.load_dygraph(modelDir)
model.load_dict(model_state_dict)
model.eval()
# 加载验证数据
eval_loader = load_data('eval')
acc_set = []
avg_loss_set = []
for batch_id, data in enumerate(eval_loader()):
x_data, y_data = data
img = fluid.dygraph.to_variable(x_data)
label = fluid.dygraph.to_variable(y_data)
predict = model(img)
acc = fluid.layers.accuracy(input=predict, label=label)
loss = fluid.layers.cross_entropy(input=predict, label=label)
avg_loss = fluid.layers.mean(loss)
acc_set.append(float(acc.numpy()))
avg_loss_set.append(float(avg_loss.numpy()))

# 计算多个batch的平均损失和准确率
acc_val_mean = np.array(acc_set).mean()
avg_loss_val_mean = np.array(avg_loss_set).mean()
print('loss={}, acc={}'.format(avg_loss_val_mean, acc_val_mean))

运行结果： 

在2轮本地cpu训练的已经可以到达95%的准确率

作业5-2：
计算视觉中常见的卷积神经网络有：LeNet、Alexnet、VGG、GooLeNet、ResNet、DenseNet

作业5

5-1：

epoch: 9, batch: 400, loss is: [0.04955979], acc is [0.98]

5-2：
常见的卷积神经网络有：LeNet, Alexnet, VGG, GooLeNet, ResNet, DenseNet, DarkNet, ShuffleNet, FlowNet

第一次作业：

问题一：在医学图像之中，对于细胞中的染色体分类，传统的方法是人工按照染色体的特征进行提取，逐个比较。费时费力。采用深度学习的方法，可以快速选择出需要的染色体位置。

问题二：机器学习特别是深度学习的出现使得人们在解决特定问题的时候不需要专门掌握大量的知识。对系统的输入数据依据该领域的雄厚知识进行精妙的变化和处理。深度学习的出现降低了问题中数据的特征变化的要求，而且具体到不同的细分任务也可以用相同的框架来进行处理，节省时间

作业5-3：

SGD0.1(better than)>SGD0.01>SGD0.001

Momentum0.1(better than)>Momentum0.01>Momentum0.001

Adgrad0.01(better than)~Adgrad0.001>>Adgrad0.1

Adam0.01(better than)~Adam0.001>>Adam0.1

Overall, Adam0.01 is the best optimizer for mnist digit recognition.

作业1-2：
①类比牛顿第二定律的案例，在你的工作和生活中还有哪些问题可以用监督学习的框架来解决？假设和参数是什么？优化目标是什么？

 工作中遇到的pattern判断，wafer 在扫完表面颗粒后，会有颗粒分布图，不同的pattern对应不同的工艺问题，如果能学习到pattern对应的工艺参数，就能帮助root cause的查找。假设是pattern 和工艺是线性关系，参数是机台的设定参数，优化目标是没有pattern

②为什么说AI工程师有发展前景？怎样从经济学（市场供需）的角度做出解读？

数据是核心，数据背后的规律是人们要做的事情，AI工程师能根据数据发现规律所有是有发展前景的。

同理，市场供需会产生各种各样的数据，这些数据背后的规律是需要人们去发现的，作为AI工程师正符合这方面的需求

作业 3-1：苹果和橘子的梯度传播

作业5-3：

1、分析损失函数曲线图源码

# 卷积神经网络
import random
import paddle.fluid as fluid
from paddle.fluid.dygraph.nn import Conv2D, Pool2D, FC
from paddle.fluid.optimizer import SGDOptimizer as SGD, MomentumOptimizer as Momentum
from paddle.fluid.optimizer import AdagradOptimizer as Adagrad, AdamOptimizer as Adam
import numpy as np
import json
import datetime
import matplotlib.pyplot as plt

# 不提交数据目录
baseDir = './../../../../../../../data/pp/aistudio'
# 保存目录
datafile = '%s/data/mnist.json' % baseDir
modelDir = '%s/model/mnist-cnn-5-3' % baseDir
# 图片尺寸28*28
img_size = 28

"""##############@@@@ 模板1: 数据处理 @@@@##############"""

def load_data(mode='train'):
# 数据集读取
file = open(datafile, encoding='utf-8')
train_set, valid_set, eval_set = json.load(file)
# 按照数据类型读取数据
data_dist = {'train': train_set, 'valid': valid_set, 'eval': eval_set}
[imgs, labels] = data_dist.get(mode)
assert len(imgs) == len(labels), "len(imgs)({}) != len(labels)({})".format(len(imgs), len(labels))
# 记录下标
index_list = list(range(len(imgs)))

# 定义数据生成器
def data_generator():
# 训练数据随机打乱
if mode == 'train':
random.shuffle(index_list)

img_list, label_list = [], []
for i in index_list:
img_list.append(np.reshape(imgs[i], [1, img_size, img_size]).astype('float32'))
label_list.append(np.reshape(labels[i], [1]).astype('int64'))
# 每批返回100个
if len(img_list) == 100:
yield np.array(img_list), np.array(label_list)
# 批次完成后重新初始化
img_list, label_list = [], []

return data_generator

"""##############@@@@ 模板2: 网络结构 @@@@##############"""

# 多层全连接神经网络实现
class MNIST(fluid.dygraph.Layer):
def __init__(self, name_scope):
super(MNIST, self).__init__(name_scope)
name_scope = self.full_name()
# 定义卷积层，输出通道20，卷积核大小为5，步长为1，padding为2，使用relu激活函数
self.conv1 = Conv2D(name_scope, num_filters=20, filter_size=5, stride=1, padding=2, act='relu')
# 定义池化层，池化核为2，采用最大池化方式
self.pool1 = Pool2D(name_scope, pool_size=2, pool_stride=2, pool_type='max')
# 定义卷积层，输出通道20，卷积核大小为5，步长为1，padding为2，使用relu激活函数
self.conv2 = Conv2D(name_scope, num_filters=20, filter_size=5, stride=1, padding=2, act='relu')
# 定义池化层，池化核为2，采用最大池化方式
self.pool2 = Pool2D(name_scope, pool_size=2, pool_stride=2, pool_type='max')
# 定义全连接层，输出节点数为10，激活函数使用softmax
self.fc = FC(name_scope, size=10, act='softmax')

# 定义网络的前向计算过程
def forward(self, inputs, label=None):
conv1 = self.conv1(inputs)
pool1 = self.pool1(conv1)
conv2 = self.conv2(pool1)
pool2 = self.pool2(conv2)
fc = self.fc(pool2)
return fc

"""##############@@@@ 模板3: 模型训练 @@@@##############"""
"""##############@@@@ 模板3-1: 优化器 @@@@##############"""
"""##############@@@@ 模板3-2: 损失函数 @@@@##############"""
"""##############@@@@ 模板3-3: 后向传播 @@@@##############"""
"""##############@@@@ 模板3-4: 保存模型 @@@@##############"""

def train(optimizer):
model = MNIST("mnist")
model.train()
# 调用加载数据的函数，获得MNIST训练数据集
train_loader = load_data('train')
# 训练5轮
EPOCH_NUM = 2
iter = 0
iters = []
losses = []
for epoch_id in range(EPOCH_NUM):
for batch_id, data in enumerate(train_loader()):
# 准备数据
image_data, label_data = data
image = fluid.dygraph.to_variable(image_data)
label = fluid.dygraph.to_variable(label_data)
# 前向计算的过程
predict = model(image)
# 计算损失，取一个批次样本损失的平均值
loss = fluid.layers.cross_entropy(predict, label)
avg_loss = fluid.layers.mean(loss)
# 每训练了100批次的数据，打印下当前Loss的情况
if batch_id % 10 == 0:
print("[{}] epoch: {}, batch_id: {}, loss is: {}".format(optimizer.__class__, epoch_id, batch_id, avg_loss.numpy()))
iters.append(iter)
losses.append(avg_loss.numpy())
iter = iter + 10

# 后向传播，更新参数的过程
avg_loss.backward()
optimizer.minimize(avg_loss)
model.clear_gradients()
return iters, losses

if __name__ == '__main__':
# 网络结构部分之后的代码，保持不变
with fluid.dygraph.guard():
fluid.optimizer.AdamOptimizer(learning_rate=0.01)
lr_list = [0.1, 0.05, 0.01, 0.005, 0.001]
color_list = ['r', 'b', 'y', 'k', 'g']
opt_list = [SGD, Momentum, Adagrad, Adam]
for opt in opt_list:
name = opt.__name__
data_list = []
for lr in lr_list:
optimizer = opt(learning_rate=lr, momentum=0.9) if name == 'MomentumOptimizer' else opt(
learning_rate=lr)
print('name = {}, optimizer = {}'.format(name, optimizer))
data_list.append(train(optimizer=optimizer))

# 画出训练过程中Loss的变化曲线
plt.figure()
plt.title('[{}] train loss'.format(name), fontsize=24)
plt.xlabel("iter", fontsize=14)
plt.ylabel("loss", fontsize=14)
for i in range(len(color_list)):
plt.plot(data_list[i][0], data_list[i][1], color=color_list[i], label='train loss [{}]'.format(lr_list[i]))
plt.grid()
plt.show()

2、各优化函数loss曲线图

3、结果分析

 在取值[0.1, 0.05, 0.01, 0.005, 0.001]上，对比SGD, Momentum, Adagrad, Adam的结果是Adam在0.005时损失函数下降最快，  并比较稳定

作业3-1

作业4-2：

通过Python、深度学习框架，不同方法写房价预测，Python编写的模型 和 基于飞桨编写的模型在哪些方面存在异同？例如程序结构，编写难易度，模型的预测效果，训练的耗时等等？

差异：效率，程序结构简洁，容易理解，编写，模型丰富，节省劳动

        1.例子：睡眠时间和精神状态之间的关系可以用监督学习的框架解决。

假设：睡眠时间(a)和精神状态(f)之间是线性关系；参数(w)：f=w*a；优化目标：最终得到的参数能很好的拟合一个人的睡眠时间和精神状态之间的关系。

        2.首先，国家制定了数字中国、智慧城市等大的规划政策，然而这些政策的实现离不开AI，所以说AI工程师在以后的发展肯定大放异彩；其次，在世界各国，AI已经成为热点，是未来发展的趋势，各国在资金、人力和物力上投入巨多；最后，各大企业也将重点放在了AI项目落地上面，来推动企业的科技创新，创造更好的服务。

作业：1-2

        1.例子：睡眠时间和精神状态之间的关系可以用监督学习的框架解决。

假设：睡眠时间(a)和精神状态(f)之间是线性关系；参数(w)：f=w*a；优化目标：最终得到的参数能很好的拟合一个人的睡眠时间和精神状态之间的关系。

        2.首先，国家制定了数字中国、智慧城市等大的规划政策，然而这些政策的实现离不开AI，所以说AI工程师在以后的发展肯定大放异彩；其次，在世界各国，AI已经成为热点，是未来发展的趋势，各国在资金、人力和物力上投入巨多；最后，各大企业也将重点放在了AI项目落地上面，来推动企业的科技创新，创造更好的服务。

作业5-1

# 加载100张图片数据

def load_image():

testset = paddle.dataset.mnist.test()

test_reader = paddle.batch(testset, batch_size=100)

for data in test_reader():

imag = np.array([x[0] for x in data]).astype('float32')

label = np.array([x[1] for x in data]).astype('float32')

return imag, label

# 定义预测过程

with fluid.dygraph.guard():

model = MNIST("mnist")

params_file_path = 'mnist'

# 加载模型参数

model_dict, _ = fluid.load_dygraph("mnist")

model.load_dict(model_dict)

model.eval()

imag, label = load_image()

result = model(fluid.dygraph.to_variable(imag))

right_sum = 0

for i in range(len(label)):

if int(result[i][0].numpy()[0])==int(label[i]):

right_sum+=1

score = right_sum/len(label)

print("预测准确率为：",score)

作业 5-2

作业5-2

作业5-2

作业5-2

       常见的卷积神经网络

LeNet、Alexnet、VGG、GooLeNet、ResNet、DenseNet

LeNet：  最早的卷积神经网络之一

Alexnet：使用ReLU作为CNN的激活函数，Dropout，在CNN中使用重叠的最大池化，提出了LRN层，使用CUDA加速深度卷积网络的训练，数据增强

VGG：小卷积核，小池化核，全连接转卷积

GooLeNet：：能更高效的利用计算资源，在相同的计算量下能提取到更多的特征，从而提升训练结果

ResNet ：设计了一种使用了skip connection的残差结构，使得网络达到很深的层次，同时提升了性能

DenseNet：从特征的角度考虑,通过特征重用和旁路(Bypass)设置,既大幅度减少了网络的参数量,又在一定程度上缓解了gradient vanishing问题的产生.结合信息流和特征复用的假设,

12月23日作业

作业4-2：使用Python和飞桨深度学习框架编写房价预测，在程序流程结构大体都一致，都是数据处理、模型设计、训练配置、训练过程、保存模型。但在编写难易度及效率方面，当然是基于飞桨框架下编写更加简单高效。并且在模型最终的预测效果也都保持一致。同时由于有框架的支持，对训练环境支持多种模式：CUP、GUP，分布式等。当然有了这些加持，训练速度大大加快，耗时更低。

12月25日作业

作业5-1：从MNIST数据-测试集中，随机抽取100张，使用“房价预测”使用的单层且没有非线性变换的线性回归模型进行预测：

# 设置数据读取器，读取MNIST数据-测试集
testset = paddle.dataset.mnist.test()
# 包装数据读取器，每次读取的数据数量设置为batch_size=1000
test_reader = paddle.batch(testset, batch_size=1000)

#读取dataNum条随机抽取的测试集数据
def randomData(dataNum):
    # 以迭代的形式读取数据
    for batch_id, data in enumerate(test_reader()):
        #通过np的随机shuffle打乱循序后再进行截取dataNum个数据集：
        data = np.array(data)#转换为numpy的array
        np.random.shuffle(data)#打乱顺序以获得随机抽取效果
        data = data[:dataNum]#打乱后截取的个数dataNum

        # 获得图像数据，并转为float32类型的数组
        img_data = np.array([x[0] for x in data]).astype('float32')
        # 获得图像标签数据，并转为float32类型的数组
        label_data = np.array([x[1] for x in data]).astype('float32')
        # 打印数据形状
        # print("图像数据形状和对应数据为:", img_data.shape, img_data[0])
        # print("图像标签形状和对应数据为:", label_data.shape, label_data[0])
        # print("图像对应标签为:", label_data[0])
        # break
        
        return img_data, label_data

#通过readData()函数返回结果每次都不同，即为随机取值：
# print("\n打印随机取得100个图像，对应标签数字为{}".format(readData(100)[1]))

# 定义预测过程
def forecast(img_data, label_data):
    with fluid.dygraph.guard():
        model = MNIST("mnist")
        #加载模型参数
        model_dict, _ = fluid.load_dygraph("mnist")
        model.load_dict(model_dict)
        model.eval()
        #传入图片信息
        tensor_img = np.array([img_data])
        #开始预测：预测输出取整，即为预测的数字
        result = model(fluid.dygraph.to_variable(tensor_img)).numpy().astype('int32')
        #打印预测结果：
        print("本次预测的数字是:", result[0],' 对应标签数字为:',int(label_data))
        if(result == label_data):
            return True
        else:
            return False

#随机取100条测试集数据
img_data, label_data = randomData(100)
#打印显示获得的100张中的第一张图片信息：
# plt.imshow(img_data[0].reshape(28, 28))

result = []
for id, ld in zip(img_data, label_data):# zip() 打包为新的元组列表
    result.append(forecast(id, ld))
print("线性回归模型测试{}张图片的正确率是：{:%}".format(100, np.sum(result) / 100))

---总结：在本次实验优化算法使用随机梯度下降SGD，学习率使用 0.01的情况下，使用mnist测试集数据，每次随机抽取100张且进行了10次预测，最高一次正确率仅为28%，准确率非常的低。

作业5-2：GoogLeNet是2014年ILSVRC图像分类算法的优胜者；ResNet来自微软的人工智能团队Microsoft Research，是2015年ILSVRC图像分类和物体识别算法的优胜者；VGGNet是牛津大学视觉几何团队（Visual Geometry Group, VGG）开发的一组卷积神经网络算法；ZFNet是2013年ILSVRC图像分类算法的优胜者；AlexNet是2012年ILSVRC图像分类和物体识别算法的优胜者；---以上来自于百度百科(っ•̀ω•́)っ✎⁾⁾ 我爱学习

作业5-3：手写数字识别，优化算法对比：

---综上，在学习率0.1,0.01,0.001各算法的效果如上。综合来看Adam下降最快，并且最稳定。

作业 4-2：

python编写的模型和使用飞桨框架的相同之处：都是基于一些基本的函数库如numpy，scipy等来编写。

不同之处：使用飞桨框架只需要考虑业务逻辑，考虑好数据的预处理，无需自行实现算法。对于一些高深的算法如共轭梯度法，使用框架提供的算法可以避免因自己数学能力不够而不能实现更好的优化迭代的效果。其次，使用框架的API函数，只需要提供符合要求的参数即可，相比于自己用python编写模型，节省了大量的时间。另外，框架很多的算法、函数的实现都经过了高度的优化，运行的效率高，因而训练耗时相比自己写模型也低得多