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

程序结构：

代码执行的效率上飞桨会比较高

编写难易度：

使用框架编写很简单，调包侠嘛，效率高。自己编写模型要有强硬的数学功底支撑，代码量看个人情况，有的是非常巨大（算法差异），而且容易出错，不适合小白。

模型的预测效果：

框架当然效果更好

训练的耗时：

深度学习框架的运算速度远远快于python编写的模型的，

使用性上：

框架使用起来很方便，支持许多的模型，直接导入数据训练就可以了。

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

1. 程序结构：飞桨结构清晰统一，Python仁者见仁，智者见智

2. 编写难易度：飞桨可照猫画虎，Python得弄清原理

3. 训练耗时：飞桨速度快, Python取决于编写者的技术水平

4. 预测效果：飞桨预测效果稳定，Python效果取决于编写者的技术水平

作业4-2:

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

大大提升了工作效率，缩短了项目实现时间，可以将更多精力放在算法的实现与改进上；

程序结构上：使得程序看上去更加简洁，易于修改维护，统一的结构上下去实现任务，很方便移植到新的任务上；逻辑上清晰易懂，便于修改。

编写难易度上：直接可以调用相关接口，便于理解，编写修改。

模型的预测效果上：以为是调试好的框架，所以可以很稳定的进行模型预测部署，效果很好。

训练耗时：飞桨框架API可以方便的选择使用cpu或者gpu，目前使用的Tesla V100很快，效果也很好。

作业4-2：

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

Paddle与其他框架都大同小异，常用的模型和网络都有实现，只是为了避免反复发明轮子。对于初学者来说，就是看哪个框架的入门文档写的更好更完善，远没到构建实现新结构和损失函数的阶段。预测效果和训练的资源与耗时那更是后话。AI Studio提供了《深度学习导论与应用实践》这书的全部代码实现和免费算力资源倒是很好的开始。

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

1.程序结构上，飞浆更加简洁，清晰，逻辑一目了然，易于更新维护；而Python则显得略微臃肿，不适合快速上手入门，需要极高的数学功底。

2.编写难易度：飞浆可以直接调用大量现成库，更加容易实现算法并测试效果；python会消耗大量时间在模型搭建 上，不利于算法创新与优化

3.飞浆有现成模型，有大量预训练模型，可以实现模型快速收敛，训练速度很快；python几乎很少有预训练模型，很多算法需要从零训练，模型收敛慢，且模型收敛速度受制于编写者本身水平。

4.预测效果：飞浆经过大量验证预测效果趋于稳定，python预测效果取决编写者代码编写水平，模型优化参差不齐，无法带来稳定的预测结果。

作业5-1：

作业5-2：

常见的卷积网络结构

1.Lenet首次让卷积神经网络登上研究界，证明机器学习到的特征也能媲美我们人类手动设计的特征

2.AlexNet，通过多个不同大小卷积核构成的卷积层，池化层得到一个不错的模型

3.VGGNet，提出以一个Block来构建网络的基本架构，后续引入BatchNormalization

4.InceptionNet 一个Block通过1x1卷积 池化 3x3 卷积 5x5卷积，最后在通道维上连结，实现较好的准确率

5.NiN，通过在卷积层中加入多层1x1卷积核，来达到全连接层的效果，实现更好的非线性变换

6.ResNet，通过跳跃连结实现残差结构，能加深网络结构，防止梯度消失

7.DenseNet，受ResNet启发，每次卷积都只卷积很少的通道数，最后连结到通道维数，并通过transition layer来减小模型参数，从而让通道信息很丰富，参数少，但是显存占用较大

8.MobileNet，提出Depthwise和Separable卷积，在达到普通卷积效果的同时，减少参数量

9.ShuffleNet，引入通道混洗的概念，进一步减少计算量

10.Mixnet， 通过多个卷积核卷积连结，减小参数量的同时提高精度

11.SEnet，创新性的引入SEBlock，计算每个通道的重要性并与对应特征图相乘，并且不需要改动原有的网络结构就可以将SEBlock应用在其他结构当中

5.3:

Adam优化算法下降Loss值更快，更容易让模型收敛

作业5.1
（代码）
#读取dataNum条随机抽取的测试集数据
def readData(dataNum):
testset = paddle.dataset.mnist.test()
test_reader = paddle.batch(testset, batch_size=10000)#一次读取全部10000条测试集数据
for batch_id, data in enumerate(test_reader()):
data = np.array(data)
np.random.shuffle(data)#打乱顺序以获得随机抽取效果
data = data[:dataNum]
img_data = np.array([x[0] for x in data])#.astype("float32")
label_data = np.array([x[1] for x in data]).astype("int32")
#print("图像数据形状为:", img_data.shape)
#print("图像标签形状和数据为:", label_data.shape, label_data)
return img_data, label_data

# 定义预测过程
def predict(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.forward(fluid.dygraph.to_variable(tensor_img)).numpy().astype('int32')[0][0]#预测输出取整，即为预测的数字
#print("本次预测的数字是", result)
if(result == label_data):
return True
else:
return False

N = 100
img_data, label_data = readData(N)#随机抽取100条测试集数据
#plt.imshow(img_data[0].reshape(28, 28))
result = []
for id, ld in zip(img_data, label_data):
result.append(predict(id, ld))
print("线性回归模型测试{}张图片的正确率是：{:%}".format(N, np.sum(result) / N))
（结论）
线性回归模型在0.001学习率下训练10轮后预测100张图片的准确率大概是20%多一点。
作业5.2
常用的卷积神经网络有：LeNet、AlexNet、VGGNet、inception、ResNet、DenseNet等，这些经典模型在分类准确率上表现越来越好，而MobileNet和ShulfleNet更适合于部署在边缘端等轻量级硬件设备上。

作业5.3
（代码）
#分别用'SGD', 'Momentum', 'Adagrad', 'Adam'四种优化算法，在0.001～0.01（递增步长0.001）学习率下训练模型时loss的变化，并边训练边记录在文件里。
fileName = ['SGD', 'Momentum', 'Adagrad', 'Adam']
def train(opti, learningRate, epoch_num):
#仅优化算法的设置有所差别
with fluid.dygraph.guard():
model = MNIST("mnist")
model.train()
#调用加载数据的函数
train_loader = load_data('train')

#四种优化算法的设置方案，可以逐一尝试效果
if opti == fileName[0]:
optimizer = fluid.optimizer.SGDOptimizer(learning_rate=learningRate)
elif opti == fileName[1]:
optimizer = fluid.optimizer.MomentumOptimizer(learning_rate=learningRate, momentum=0.9)
elif opti == fileName[2]:
optimizer = fluid.optimizer.AdagradOptimizer(learning_rate=learningRate)
elif opti == fileName[3]:
optimizer = fluid.optimizer.AdamOptimizer(learning_rate=learningRate)

avgLostArr = []
EPOCH_NUM = epoch_num
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)
avgLostArr.append(avg_loss.numpy()[0])

#每训练了100批次的数据，打印下当前Loss的情况
if batch_id % 200 == 0:
print("epoch: {}, batch: {}, loss is: {}".format(epoch_id, batch_id, avg_loss.numpy()))

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

#保存模型参数
fluid.save_dygraph(model.state_dict(), 'mnist')

#print(len(avgLostArr))
#print(avgLostArr)
optimizerName = opti+'_lr_'+str(learningRate)
np.save("./"+optimizerName, np.array(avgLostArr))
arr = np.load(optimizerName+'.npy')
print(optimizerName+'.npy', len(arr), opti, learningRate, epoch_num)
#print(arr)
return(avgLostArr)

for j in range(10):
for i in range(len(fileName)):
train(fileName[i], 0.001 * (j + 1), 1)

#用2d和3d图表显示各种优化算法的效果
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

color = ['blue', 'orange', 'green', 'red']
fileName = ['SGD', 'Momentum', 'Adagrad', 'Adam']
length = 200

def showPic(lr = 0.01, length = 200):
learningRate = str(lr)
plt.figure(figsize=(12,8),dpi=80)
for i in range(len(fileName)):
loss = np.load(fileName[i]+'_lr_'+learningRate+'.npy')
loss = loss[:length]
#print(loss.shape)
plt.plot(range(len(loss)), loss, label=fileName[i]+'_lr_'+learningRate, color=color[i])
plt.legend(loc="upper right")
plt.xlabel('Iteration(learning rate = {})'.format(learningRate))
plt.ylabel('Loss')
plt.show()

for i in range(10):
showPic(0.001 * (i + 1))

def loadLoss(lr = 0.01, length = 200):
learningRate = str(lr)
lossArr = []
for i in range(len(fileName)):
loss = np.load(fileName[i]+'_lr_'+learningRate+'.npy')
loss = loss[:length]
#print(loss.shape)
lossArr.append(loss)
return np.array(lossArr)

lossFrame = []
for i in range(10):
lossFrame.append(loadLoss(0.001 * (i + 1)))
lossFrame = np.array(lossFrame)
#print(lossFrame.shape)
#print(lossFrame.shape[2])

fig = plt.figure(figsize=(12, 8))
ax = Axes3D(fig)
X = np.arange(0, lossFrame.shape[2], 1)
Y = np.arange(0, lossFrame.shape[0] / 1000, 1 / 1000)
X, Y = np.meshgrid(X, Y) #必须加上这段代码

def getZ(i = 0):
Z = []
for y in range(lossFrame.shape[0]):
xArr = []
for x in range(lossFrame.shape[2]):
xArr.append(lossFrame[y][i][x])
xArr = np.array(xArr)
Z.append(xArr)
Z = np.array(Z)
return Z
for i in range(lossFrame.shape[1]):
Z = getZ(i)
ax.plot_surface(X, Y, Z, rstride=1, cstride=1, label='fileName[i]')
ax.set_xlabel('Iteration', color='r')
ax.set_ylabel('Learning Rate', color='r')
ax.set_zlabel('Loss', color='r')
# ax.legend()

plt.show()

（结论）
1.'Momentum', 'Adagrad', 'Adam'三种优化算法再各个学习率下的优化效果都好于'SGD'。优化算法性能比较结果为:'Adam'>'Adagrad'>'Momentum'>'SGD'。
2.学习率越低，这几种优化算法的效率差别越明显。在实际应用中过大的学习率可能会导致模型无法收敛，所以'Adam'等更为优化的算法在较小的学习率下能帮助模型快速收敛是很有帮助的。

(优化算法比较的图表)

12月10日课间作业

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

 预测某热点区域基站的流量，假设框架模型是线性的，模型参数和要预测的时间，地点基站的配置，前一阶段的流量参数有关联，优化目标是预测的流量和实际的流量。

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

以深度学习为基础的AI技术在各行各业的应用价值在于，可以不完全依赖于传统的相关领域知识，在具备基本的高数知识，基本的编程知识的前提的前提下，可以快速解决相关行业问题，节约了学习的时间，而且AI在不同行业中的应用其理论机构都是相同的，可以做到举一反三，加快了发展的进程。

从权值的变化曲线的对比可以看出Paddle网络的各个权值变化的总是领先于手写网络，loss也下降得更快。

作业2-1：

class Network(object):

   def __init__(self, num_of_weights):
   # 随机产生w的初始值
  # 为了保持程序每次运行结果的一致性，此处设置固定的随机数种子
  #np.random.seed(0)
    self.w1 = np.random.randn(num_of_weights, 13)
    self.b1 = 0.
    self.w2 = np.random.randn(13, 1)
   self.b2 = 0.

  def forward(self, x):
   z1 = np.dot(x, self.w1) + self.b1
  z2 = np.dot(z1, self.w2) + self.b2
  self.z1 = z1
  return z2

  def loss(self, z, y):
   error = z - y
   num_samples = error.shape[0]
   cost = error * error
   cost = np.sum(cost) / num_samples
   return cost

  def gradient(self, x, y):
   z = self.forward(x)
   N = x.shape[0]
   gradient_x2 = 1. / N * np.dot(z-y, self.w2.T)
   self.gradient_w2 = 1. / N * np.dot(self.z1.T, (z-y))
  self.gradient_b2 = 1. / N * np.sum(z-y)
  self.gradient_w1 = 1. / N * np.dot(x.T, gradient_x2)
  self.gradient_b1 = 1. / N * np.sum(gradient_x2, axis=0)
  self.gradient_b1 = self.gradient_b1[np.newaxis,:]

   def update(self, eta = 0.01):
    self.w2 = self.w2 - eta * self.gradient_w2
    self.b2 = self.b2 - eta * self.gradient_b2
    self.w1 = self.w1 - eta * self.gradient_w1
    self.b1 = self.b1 - eta * self.gradient_b1

  def train(self, training_data, num_epoches, batch_size=10, eta=0.01):
   n = len(training_data)
   losses = []
   for epoch_id in range(num_epoches):
# 在每轮迭代开始之前，将训练数据的顺序随机的打乱，
# 然后再按每次取batch_size条数据的方式取出
   np.random.shuffle(training_data)
# 将训练数据进行拆分，每个mini_batch包含batch_size条的数据
   mini_batches = [training_data[k:k+batch_size] for k in range(0, n, batch_size)]
   for iter_id, mini_batch in enumerate(mini_batches):
#print(self.w.shape)
#print(self.b)
   x = mini_batch[:, :-1]
   y = mini_batch[:, -1:]
   a = self.forward(x)
   loss = self.loss(a, y)
   self.gradient(x, y)

   self.update(eta)
   losses.append(loss)
   print('Epoch {:3d} / iter {:3d}, loss = {:.4f}'.
   format(epoch_id, iter_id, loss))

   return losses

作业5-1：
此处基于2-8的code作为base,在第一个cell后运行。
1) 单张图（数字0）测试
代码如下：

import matplotlib.image as mpimg
import matplotlib.pyplot as plt
# Load Image
def load_image(img_path):
    im = Image.open(img_path).convert('L')
    im.show()
    im = im.resize((28, 28), Image.ANTIALIAS)
    im = np.array(im).reshape(1, 1, 28, 28).astype(np.float32)
    im = 1.0 - im / 255.
    return im

with fluid.dygraph.guard():
    model = MNIST("mnist")
    params_file_path = 'mnist'
    img_path = './work/example_0.png'
    model_dict, _ = fluid.load_dygraph("mnist")
    model.load_dict(model_dict)
    model.eval()

    # Show Image
    img = mpimg.imread(img_path)
    plt.imshow(img)
    
    # Predict Image
    tensor_img = load_image(img_path)
    results = model(fluid.dygraph.to_variable(tensor_img))
    lab = np.argsort(results.numpy())
    print("本次预测的数字是: ", lab[0][-1])

结果如下：

2) 随机抽取100张，测试准确率
代码如下：

def get_testdata(num):
    datafile = './work/mnist.json.gz'
    print('loading mnist dataset from {} ......'.format(datafile))
    data = json.load(gzip.open(datafile))
    _, _, eval_set = data
    IMG_ROWS = 28
    IMG_COLS = 28
    test_imgs = np.array(eval_set[0]).reshape(10000, 1, IMG_ROWS, IMG_COLS).astype('float32')
    test_labels = np.array(eval_set[1]).reshape(10000, 1).astype('int64')
    test_length = len(test_imgs)
    assert len(test_imgs) == len(test_labels), \
          "length of train_imgs({}) should be the same as train_labels({})".format(
                  len(test_imgs), len(test_labels))
    index_list = list(range(test_length))
    np.random.shuffle(index_list)
    if num

def test_different_opt(optimizer):
    BATCHSIZE=100
    use_gpu = True
    place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
    
    all_train_iter=0
    all_train_iters=[]
    all_train_costs=[]
    all_train_accs=[]
    
    with fluid.dygraph.guard(place):
        model = MNIST("mnist")
        model.train() 
        
        optimizer = optimizer
        
        EPOCH_NUM = 5
        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, avg_acc = model(image, label)
                
                #计算损失，取一个批次样本损失的平均值
                loss = fluid.layers.cross_entropy(predict, label)
                avg_loss = fluid.layers.mean(loss)
                acc = fluid.layers.accuracy(input=predict, label=label) 
                
                all_train_iter += BATCHSIZE
                all_train_iters.append(all_train_iter)
                all_train_costs.append(avg_loss[0].numpy()[0])
                all_train_accs.append(acc[0].numpy()[0])
                
                #每训练了200批次的数据，打印下当前Loss的情况
                if batch_id % 200 == 0:
                    print("epoch: {}, batch: {}, loss is: {}, acc is {}".format(epoch_id, batch_id, avg_loss.numpy(),avg_acc.numpy()))
                
                #后向传播，更新参数的过程
                avg_loss.backward()
                optimizer.minimize(avg_loss)
                model.clear_gradients()
    return all_train_iters, all_train_costs

lr_list = [1e-4, 5e-4, 2.5e-3, 1.25e-2, 6.25e-2, 3.125e-1]
opt_list = [
    ('SGD',fluid.optimizer.SGDOptimizer),
    ('Momentum',fluid.optimizer.MomentumOptimizer),
    ('Adagrad',fluid.optimizer.AdagradOptimizer),
    ('Adam',fluid.optimizer.AdamOptimizer)
]
optimizers_list = [
    (opt(learning_rate=lr), opt_name + '_' + str(lr)) 
    if opt_name!='Momentum' else (opt(learning_rate=lr, momentum=0.9), opt_name + '_' + str(lr))
    for (opt_name, opt) in opt_list
    for lr in lr_list]
test_result_dict = {}
for (optimizer, test_case_name) in optimizers_list:
    print(f"Testing Case: {test_case_name}")
    all_train_iters, all_train_costs = test_different_opt(optimizer)
    test_result_dict[test_case_name] = [all_train_iters, all_train_costs]

from matplotlib import pyplot as plt
def plot_test_result(test_result_dict):
    plt.figure(figsize=(12,12))
    test_case_names = list(test_result_dict.keys())
    opt_names = list(set([case_name.split('_')[0] for case_name in test_case_names]))
    opt_lrs = sorted(list(set([float(case_name.split('_')[1]) for case_name in test_case_names])))
    common_color_list = ['b','g','r','c','m','y','k']
    common_shape_list = ['x','D','o','s','^','p','>','*','+','v','h','H','^','.',',','d','|','_']
    legend_list = []
    for i in range(len(opt_names)):
        for j in range(len(opt_lrs)):
            test_case_name = opt_names[i] + '_' + str(opt_lrs[j])
            plt.plot(
                test_result_dict[test_case_name][0][:30],test_result_dict[test_case_name][1][:30],
                color = common_color_list[i],
                marker = common_shape_list[j]
            )
            legend_list.append(test_case_name)
    plt.legend(legend_list, loc=1)
    plt.xlabel('Iteration')
    plt.ylabel('Loss')
    plt.title("All Optimizer Comparison")
    plt.xlim(0, 3000)
    plt.ylim(0,10)
    plt.show()
    
    def subplot(name, i, y_max):
        legend_list = []
        plt.figure(figsize=(6,6))
        for j in range(len(opt_lrs)):
            test_case_name = name + '_' + str(opt_lrs[j])
            plt.plot(
                test_result_dict[test_case_name][0][:30],test_result_dict[test_case_name][1][:30],
                color = common_color_list[i],
                marker = common_shape_list[j]
            )
            legend_list.append(test_case_name)
        plt.legend(legend_list, loc=1)
        plt.xlabel('Iteration')
        plt.ylabel('Loss')
        plt.xlim(0, 3000)
        plt.ylim(0,y_max)
        plt.title(f"Optimizer : {name}")
        plt.show()
    for i in range(len(opt_names)):
        subplot(opt_names[i], i, y_max=5)
    
plot_test_result(test_result_dict)

修正#572，第二段代码有缺失补充如下

def get_testdata(num):
    datafile = './work/mnist.json.gz'
    print('loading mnist dataset from {} ......'.format(datafile))
    data = json.load(gzip.open(datafile))
    _, _, eval_set = data
    IMG_ROWS = 28
    IMG_COLS = 28
    test_imgs = np.array(eval_set[0]).reshape(10000, 1, IMG_ROWS, IMG_COLS).astype('float32')
    test_labels = np.array(eval_set[1]).reshape(10000, 1).astype('int64')
    test_length = len(test_imgs)
    assert len(test_imgs) == len(test_labels), \
          "length of train_imgs({}) should be the same as train_labels({})".format(
                  len(test_imgs), len(test_labels))
    index_list = list(range(test_length))
    np.random.shuffle(index_list)
    if num

作业4-2:

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

对比于非框架方式飞桨编写的模型结构更清晰，更方便于程序员调用细节修改

【源码的缩进没了，再发一次】

#（作业5.1）读取dataNum条随机抽取的测试集数据
def readData(dataNum):
    testset = paddle.dataset.mnist.test()
    test_reader = paddle.batch(testset, batch_size=10000)#一次读取全部10000条测试集数据
    for batch_id, data in enumerate(test_reader()):
        data = np.array(data)
        np.random.shuffle(data)#打乱顺序以获得随机抽取效果
        data = data[:dataNum]
        img_data = np.array([x[0] for x in data])#.astype("float32")
        label_data = np.array([x[1] for x in data]).astype("int32")
        #print("图像数据形状为:", img_data.shape)
        #print("图像标签形状和数据为:", label_data.shape, label_data)
        return img_data, label_data

# 定义预测过程
def predict(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.forward(fluid.dygraph.to_variable(tensor_img)).numpy().astype('int32')[0][0]#预测输出取整，即为预测的数字
        #print("本次预测的数字是", result)
        if(result == label_data):
            return True
        else:
            return False

N = 100
img_data, label_data = readData(N)#随机抽取100条测试集数据
#plt.imshow(img_data[0].reshape(28, 28))
result = []
for id, ld in zip(img_data, label_data):
    result.append(predict(id, ld))
print("线性回归模型测试{}张图片的正确率是：{:%}".format(N, np.sum(result) / N))


#（作业5.3）分别用'SGD', 'Momentum', 'Adagrad', 'Adam'四种优化算法，在0.001～0.01（递增步长0.001）学习率下训练模型时loss的变化，并边训练边记录在文件里。
fileName = ['SGD', 'Momentum', 'Adagrad', 'Adam']
def train(opti, learningRate, epoch_num):
    #仅优化算法的设置有所差别
    with fluid.dygraph.guard():
        model = MNIST("mnist")
        model.train()
        #调用加载数据的函数
        train_loader = load_data('train')
    
        #四种优化算法的设置方案，可以逐一尝试效果
        if opti == fileName[0]:
            optimizer = fluid.optimizer.SGDOptimizer(learning_rate=learningRate)
        elif opti == fileName[1]:
            optimizer = fluid.optimizer.MomentumOptimizer(learning_rate=learningRate, momentum=0.9)
        elif opti == fileName[2]:
            optimizer = fluid.optimizer.AdagradOptimizer(learning_rate=learningRate)
        elif opti == fileName[3]:
            optimizer = fluid.optimizer.AdamOptimizer(learning_rate=learningRate)
    
        avgLostArr = []
        EPOCH_NUM = epoch_num
        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)
                avgLostArr.append(avg_loss.numpy()[0])
            
                #每训练了100批次的数据，打印下当前Loss的情况
                if batch_id % 200 == 0:
                    print("epoch: {}, batch: {}, loss is: {}".format(epoch_id, batch_id, avg_loss.numpy()))
            
                #后向传播，更新参数的过程
                avg_loss.backward()
                optimizer.minimize(avg_loss)
                model.clear_gradients()

        #保存模型参数
        fluid.save_dygraph(model.state_dict(), 'mnist')
    
        #print(len(avgLostArr))
        #print(avgLostArr)
        optimizerName = opti+'_lr_'+str(learningRate)
        np.save("./"+optimizerName, np.array(avgLostArr))
        arr = np.load(optimizerName+'.npy')
        print(optimizerName+'.npy', len(arr), opti, learningRate, epoch_num)
        #print(arr)
        return(avgLostArr)

for j in range(10):
    for i in range(len(fileName)):
        train(fileName[i], 0.001 * (j + 1), 1)

#用2d和3d图表显示各种优化算法的效果
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

color = ['blue', 'orange', 'green', 'red']
fileName = ['SGD', 'Momentum', 'Adagrad', 'Adam']
length = 200

def showPic(lr = 0.01, length = 200):
    learningRate = str(lr)
    plt.figure(figsize=(12,8),dpi=80)
    for i in range(len(fileName)):
        loss = np.load(fileName[i]+'_lr_'+learningRate+'.npy')
        loss = loss[:length]
        #print(loss.shape)
        plt.plot(range(len(loss)), loss, label=fileName[i]+'_lr_'+learningRate, color=color[i])
    plt.legend(loc="upper right")
    plt.xlabel('Iteration(learning rate = {})'.format(learningRate))
    plt.ylabel('Loss')
    plt.show()

for i in range(10):
    showPic(0.001 * (i + 1))
    
def loadLoss(lr = 0.01, length = 200):
    learningRate = str(lr)
    lossArr = []
    for i in range(len(fileName)):
        loss = np.load(fileName[i]+'_lr_'+learningRate+'.npy')
        loss = loss[:length]
        #print(loss.shape)
        lossArr.append(loss)
    return np.array(lossArr)

lossFrame = []
for i in range(10):
    lossFrame.append(loadLoss(0.001 * (i + 1)))
lossFrame = np.array(lossFrame)
#print(lossFrame.shape)
#print(lossFrame.shape[2])

fig = plt.figure(figsize=(12, 8))
ax = Axes3D(fig)
X = np.arange(0, lossFrame.shape[2], 1)
Y = np.arange(0, lossFrame.shape[0] / 1000, 1 / 1000)
X, Y = np.meshgrid(X, Y) #必须加上这段代码

def getZ(i = 0):
    Z = []
    for y in range(lossFrame.shape[0]):
        xArr = []
        for x in range(lossFrame.shape[2]):
            xArr.append(lossFrame[y][i][x])
        xArr = np.array(xArr)
        Z.append(xArr)
    Z = np.array(Z)
    return Z
for i in range(lossFrame.shape[1]):
    Z = getZ(i)
    ax.plot_surface(X, Y, Z, rstride=1, cstride=1, label='fileName[i]')
    ax.set_xlabel('Iteration', color='r')
    ax.set_ylabel('Learning Rate', color='r')
    ax.set_zlabel('Loss', color='r')
#    ax.legend()

plt.show()

作业4-2：对于Python、深度学习框架编写房价预测模型而言，两者相同的地方：程序整体结构是一样的，都包括：数据处理、网络/模型设计、网络训练等过程；不同的地方在于：对于网络设计、训练等过程的实现是自己用numpy编写还是直接调用框架的函数进行完成。正是由于这种差别导致两种方法的结果产生很大的区别：

1）手动编写模型，需要计算繁琐的矩阵运算、梯度反馈等等过程，劳动程度大、设计繁琐而且极其容易出错；而采用深度学习框架进行编写模型时，用户只需要关注模型的逻辑过程，根本不需要具体实现每个细节，因此能够减小重复劳动过程，简单而且不容易出错，因此效率、质量会大大提高；

2）由于框架对优化算法等实现进行了优化提升，因此模型的预测效果明显优于手动编写的模型预测结果，而且训练过程简洁、快速，明显要优于手动编写。

作业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)

结果：预测准确率为： 0.28

作业5-2：

(1)LeNet

网络特点

·       每个卷积层包括三部分：卷积、池化和非线性激活函数（sigmoid激活函数）

·       使用卷积提取空间特征

·       降采样层采用平均池化

(2)AlexNet

网络特点

·       使用两块GPU并行加速训练，大大降低了训练时间

·       成功使用ReLu作为激活函数，解决了网络较深时的梯度弥散问题

·       使用数据增强、dropout和LRN层来防止网络过拟合，增强模型的泛化能力

(3)VGGNet

4）ResNet

(5)Inception

(6)DenseNet

(7)MobileNet

(8)ShuffleNet

作业5-3：

学习率设置为0.01的情况下：

（1）使用SGD：

（2）使用Adagrad

（3）使用Adam

(4) 使用Momentum

由上图可知，使用Momentum优化器明显优于其他优化器。

接下来，使用Momentum优化器，分析学习率的影响：

学习率为0.02时：

学习率为0.05时：

学习率为0.08时：

学习率为0.1时：

可以看出，学习率为0.08时效果比较好。

作业 4-2：

程序结构：基于飞桨编写程序结构会简单一些，内部模块已经封装好了，只需要调用，适合已经掌握模型的学习者，而Python编写的模型要自己设计模型内部程序结构，则是更适合初学者，能够更好的去掌握模型。

编写难易度：python编写模型需要对模型内在原理掌握非常透彻，编程基础扎实，基于飞桨编写的模型比较简单，不用自己写内部结构。

模型的预测效果：差别很小

训练的耗时：飞桨使用起来很方便，支持许多的模型，可以按需调用

作业3-1 （1）

#设置图片大小
plt.figure(figsize=(8, 3))

# x是1维数组，数组大小是从-10. 到10.的实数，每隔0.1取一个点
x = np.arange(-10, 10, 0.1)
# 计算 tanh函数
s = (np.exp(x)-np.exp(-x)) / (np.exp(x)+np.exp(-x))

#########################################################
# 以下部分为画图程序

# 设置两个子图窗口，将Sigmoid的函数图像画在左边
f = plt.subplot(111)
# 画出函数曲线
plt.plot(x, s, color='r')
# 添加文字说明
plt.text(-5., 0.9, r'$y=tanh(x)$', fontsize=13)
# 设置坐标轴格式
currentAxis=plt.gca()
currentAxis.xaxis.set_label_text('x', fontsize=15)
currentAxis.yaxis.set_label_text('y', fontsize=15)
plt.show()

（2）

p = np.random.randn(10, 10)
q=(p>0)
size = q[q==True].size
print("q type: ",q.dtype)
print("p>0 size:%d" % (size))

output:
('q type: ', dtype('bool'))
p>0 size:54

5.3 SGD：loading mnist dataset from ./work/mnist.json.gz ......
epoch: 0, batch: 0, loss is: [2.9618337]
epoch: 0, batch: 200, loss is: [0.4345165]
epoch: 0, batch: 400, loss is: [0.29857]
epoch: 1, batch: 0, loss is: [0.29973477]
epoch: 1, batch: 200, loss is: [0.3055033]
epoch: 1, batch: 400, loss is: [0.31092504]
epoch: 2, batch: 0, loss is: [0.12711337]
epoch: 2, batch: 200, loss is: [0.14189658]
epoch: 2, batch: 400, loss is: [0.15307161]
epoch: 3, batch: 0, loss is: [0.14300567]
epoch: 3, batch: 200, loss is: [0.12479535]
epoch: 3, batch: 400, loss is: [0.15392835]
epoch: 4, batch: 0, loss is: [0.14617053]
epoch: 4, batch: 200, loss is: [0.05970785]
epoch: 4, batch: 400, loss is: [0.05193378]

Adagrad：epoch: 0, batch: 0, loss is: [23.737549]
epoch: 0, batch: 200, loss is: [4.6651053]
epoch: 0, batch: 400, loss is: [4.042445]
epoch: 1, batch: 0, loss is: [4.210341]
epoch: 1, batch: 200, loss is: [2.9507055]
epoch: 1, batch: 400, loss is: [3.4136646]
epoch: 2, batch: 0, loss is: [3.1289194]
epoch: 2, batch: 200, loss is: [3.2356896]
epoch: 2, batch: 400, loss is: [2.4643185]
epoch: 3, batch: 0, loss is: [2.3309803]
epoch: 3, batch: 200, loss is: [2.6524985]
epoch: 3, batch: 400, loss is: [2.4528985]
epoch: 4, batch: 0, loss is: [2.2842317]
epoch: 4, batch: 200, loss is: [3.308255]
epoch: 4, batch: 400, loss is: [2.6887434]

momentum: =0.9时：loading mnist dataset from ./work/mnist.json.gz ......
epoch: 0, batch: 0, loss is: [2.591081]
epoch: 0, batch: 200, loss is: [0.16422454]
epoch: 0, batch: 400, loss is: [0.10947473]
epoch: 1, batch: 0, loss is: [0.08388128]
epoch: 1, batch: 200, loss is: [0.08706795]
epoch: 1, batch: 400, loss is: [0.08236799]
epoch: 2, batch: 0, loss is: [0.0452076]
epoch: 2, batch: 200, loss is: [0.06045965]
epoch: 2, batch: 400, loss is: [0.10962741]
epoch: 3, batch: 0, loss is: [0.14246346]
epoch: 3, batch: 200, loss is: [0.01536376]
epoch: 3, batch: 400, loss is: [0.04603417]
epoch: 4, batch: 0, loss is: [0.05770358]
epoch: 4, batch: 200, loss is: [0.03400549]
epoch: 4, batch: 400, loss is: [0.02229908]

Adam：loading mnist dataset from ./work/mnist.json.gz ......
epoch: 0, batch: 0, loss is: [2.3773913]
epoch: 0, batch: 200, loss is: [0.0413083]
epoch: 0, batch: 400, loss is: [0.01793065]
epoch: 1, batch: 0, loss is: [0.14884354]
epoch: 1, batch: 200, loss is: [0.018266]
epoch: 1, batch: 400, loss is: [0.05751669]
epoch: 2, batch: 0, loss is: [0.02920404]
epoch: 2, batch: 200, loss is: [0.02762874]
epoch: 2, batch: 400, loss is: [0.02966366]
epoch: 3, batch: 0, loss is: [0.0087466]
epoch: 3, batch: 200, loss is: [0.04129151]
epoch: 3, batch: 400, loss is: [0.12814976]
epoch: 4, batch: 0, loss is: [0.06855652]
epoch: 4, batch: 200, loss is: [0.03979217]
epoch: 4, batch: 400, loss is: [0.05869739]

可知在学习率都是0.01的情况下，Momentum效果最好，接下来应该在该算法的 两个参数 学习率和动量因子之中进行调试

[==================================================]t/t10k-images-idx3-ubyte.gz not found, downloading https://dataset.bj.bcebos.com/mnist/t10k-images-idx3-ubyte.gz
[==================================================]t/t10k-labels-idx1-ubyte.gz not found, downloading https://dataset.bj.bcebos.com/mnist/t10k-labels-idx1-ubyte.gz

线性回归模型测试100张图片的正确率是：23.000000%