作业2-1：

（1）基础题：

（2）挑战题：

仿照keras的API实现了一个通用的全连接神经网络，可以使用任意数量的隐藏层，同时支持了激活函数。

课上用的是一层的全连接，输入是 13， 输出是 1，使用线性激活函数。

本题使用的两层全连接，两层输入分别都是 13，输出为 1， 也使用线性激活函数。结尾处是两者损失的比较。

import numpy as np
import matplotlib.pyplot as plt


def load_data():
    # 从文件导入数据
    datafile = './data/housing.data'
    data = np.fromfile(datafile, sep=' ')

    # 每条数据包括14项，其中前面13项是影响因素，第14项是相应的房屋价格中位数
    feature_names = ['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE',
                     'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV']
    feature_num = len(feature_names)

    # 将原始数据进行Reshape，变成[N, 14]这样的形状
    data = data.reshape([data.shape[0] // feature_num, feature_num])

    # 将原数据集拆分成训练集和测试集
    # 这里使用80%的数据做训练，20%的数据做测试
    # 测试集和训练集必须是没有交集的
    ratio = 0.8
    offset = int(data.shape[0] * ratio)
    training_data = data[:offset]

    # 计算train数据集的最大值，最小值，平均值
    maximums, minimums, avgs = training_data.max(axis=0), training_data.min(axis=0), \
        training_data.sum(axis=0) / training_data.shape[0]

    # 对数据进行归一化处理
    for i in range(feature_num):
        data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i])

    # 训练集和测试集的划分比例
    training_data = data[:offset]
    test_data = data[offset:]
    return training_data, test_data


class FullConnectedLayer(object):

    def __init__(self, input_size, output_size, activation):
        '''
        input_size: 本层输入向量的维度
        output_size: 本层输出向量的维度
        activation: 激活函数
        '''
        np.random.seed(0)
        self.input_size = input_size
        self.output_size = output_size
        self.activation = activation
        # 权重数组W
        self.W = np.random.randn(input_size, output_size)
        # 偏置项b
        self.b = np.zeros((1, output_size))
        # 输出向量
        self.output = np.zeros((1, output_size))

    def forward(self, input_array):
        self.input = input_array
        self.output = self.activation.forward(np.dot(input_array, self.W) + self.b)

    def backward(self, delta_array):
        ''' 反向计算W和b的梯度
        delta_array: 从上一层传递过来的误差项
        '''
        self.W_grad = np.dot(self.input.T, delta_array)
        self.b_grad = np.mean(delta_array, axis=0)
        return self.activation.backward(self.input) * np.dot(delta_array, self.W.T)

    def update(self, learning_rate):
        self.W += learning_rate * self.W_grad
        self.b += learning_rate * self.b_grad


class SigmoidActivation(object):

    def forward(self, weighted_input):
        return 1.0 / (1.0 + np.exp(-weighted_input))

    def backward(self, output):
        return output * (1 - output)


class LinearActivation(object):

    def forward(self, weighted_input):
        return weighted_input

    def backward(self, output):
        return output


class Network(object):

    def __init__(self, layers):
        self.layers = []
        for i in range(len(layers) - 1):
            self.layers.append(
                FullConnectedLayer(
                    layers[i], layers[i + 1],
                    LinearActivation()
                )
            )

    def forward(self, sample):
        output = sample
        for layer in self.layers:
            layer.forward(output)
            output = layer.output
        return output

    def backward(self, label):
        delta = self.layers[-1].activation.backward(1) * (label - self.layers[-1].output) / len(label)
        for layer in self.layers[::-1]:
            delta = layer.backward(delta)
        return delta

    def update(self, rate):
        for layer in self.layers:
            layer.update(rate)

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

    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):
            np.random.shuffle(training_data)
            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):
                x = mini_batch[:, :-1]
                y = mini_batch[:, -1:]
                a = self.forward(x)
                loss = self.loss(a, y)
                self.backward(y)
                self.update(eta)
                losses.append(loss)
                print('Epoch {:3d} / iter {:3d}, loss = {:.4f}'.format(epoch_id, iter_id, loss))

        return losses


# 获取数据
train_data, test_data = load_data()

# 创建网络
net1 = Network([13, 1])
losses1 = net1.train(train_data, num_epoches=50, batch_size=100, eta=0.1)

net2 = Network([13, 13, 1])
losses2 = net2.train(train_data, num_epoches=50, batch_size=100, eta=0.1)

# 画出损失函数的变化趋势
plt.plot(np.arange(len(losses1)), np.array(losses1), label="one-hidden layer")
plt.plot(np.arange(len(losses2)), np.array(losses2), label="two-hidden layer")
plt.legend()
plt.show()

作业3-1：

（1）画出tanh图

import numpy as np
import matplotlib.pyplot as plt


def tanh(x):
    y = (np.exp(x) - np.exp(-x)) / (np.exp(x) + np.exp(-x))
    return y


def plot_tanh():
    x = np.arange(-10, 10.01, 0.01)
    y = tanh(x)
    plt.plot(x, y)
    plt.show()


if __name__ == "__main__":
    plot_tanh()

(2)统计大于0的个数

统计一下`q`中不为0的个数即为大于0的个数，因为在Python中，True的值为1，False的值为 0，因此统计一下非零元素个数就好了。

import numpy as np

np.random.seed(0)


def find_larger_than_zero():
    p = np.random.randn(10, 10)
    q = (p > 0)
    print(q)
    print(np.count_nonzero(q))


if __name__ == "__main__":
    find_larger_than_zero()

结果为 55

作业3-1（1）

# -*- coding: utf-8 -*-

import numpy as np
import matplotlib.pyplot as plt

# 使用numpy计算tanh函数

def main():

x = np.arange(-10, 10, 0.1)
y = (np.exp(x) - np.exp(-x)) / (np.exp(x) + np.exp(-x))

#########################################################
# 以下部分为画图程序
# 画出函数曲线
plt.plot(x, y, color='r')
# 添加文字说明
plt.text(-5., 0.9, r'$y=\sigma(x)$', fontsize=13)
# 设置坐标轴格式
currentAxis = plt.gca()
currentAxis.xaxis.set_label_text('x', fontsize=15)
currentAxis.yaxis.set_label_text('y', fontsize=15)

plt.show()

if __name__ == '__main__':
main()

（2）

# -*- coding: utf-8 -*-
import numpy as np

# 统计随机生成的矩阵中有多少元素的值大于0

def main():
p = np.random.randn(10, 10)
q = p > 0
print('随机数构成的矩阵中大于零元素个数为：{}'.format(q.sum()))

if __name__ == '__main__':
main()

# 输出->随机数构成的矩阵中大于零元素个数为：52

作业3-1

（1）

（2）

作业3-1

1.  使用numpy计算tanh激活函数

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as patches

#设置图片大小
plt.figure(figsize=(4, 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))

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

# 将tanh的函数图像画在左边
#f = plt.subplot(111)
# 画出函数曲线
plt.plot(x, y, color='g')
# 添加文字说明
plt.text(-5.0, 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. 统计随机生成矩阵中有多少个元素大于0

import numpy as np

p = np.random.randn(10, 10)
q = (p>0)
q.sum()

作业3-1：

（1）

import numpy as np
import matplotlib.pyplot as plt

def tanh(x):
   y = (np.exp(x) - np.exp(-x)) / (np.exp(x) + np.exp(-x))
   return y

x = np.arange(-10, 10.01, 0.01)

y = tanh(x)
plt.plot(x, y)
plt.show()

(2)

import numpy as np

p = np.random.randn(10, 10)
q = (p > 0)
print(q)
print(np.count_nonzero(q))

输出为 48

作业3-1

（1）

import numpy as np
import matplotlib.pyplot as plt


def tanh(x):
    y = (np.exp(x) - np.exp(-x)) / (np.exp(x) + np.exp(-x))
    return y

x = np.arange(-10, 10, 0.01)
y = tanh(x)
plt.plot(x, y)
plt.show()

（2）

p = np.random.randn(10, 10)
q = (p > 0)
print(q)
print(np.count_nonzero(q))

52

作业3-1

（1）

import numpy as np
import matplotlib.pyplot as plt

x = np.arange(-10,10,0.1)
y = (np.exp(x) - np.exp(-x)) / (np.exp(x) + np.exp(-x))
plt.plot(x, y)
plt.show()

（2）

import numpy as np
p = np.random.randn(10, 10)
q = np.sum(p > 0)
print q

作业4-2：

1.首先拿飞桨框架编写程序结构更加清晰，在定义多层感知机，隐藏层的时候，我们使用一个dygraph.FC就可以完成。

并且进行梯度计算，不需要自己根据函数求导来编写，使用飞桨框架可以很轻松进行梯度计算，后向传播，并进行后续的优化。

而且飞桨框架会将运算过程送到后端C++进行加速优化，我们自己写的代码基于python的话，速度可能没那么快。

作业4-2：

飞桨更加方便快捷，代码更加简洁。

作业4-2：首先使用传统的Python实现房价预测，需要自己一步一步手写代码，难免有错和效率不高。而使用框架进行完成简单方便。在程序结构，代码难易程度，效率等都比较好，还有模型效果也很好。PaddlePaddle在代码理解程度、API丰富程度、模型丰富程度、文档完整程度、训练过程、预测过程对于学习都有很大提升。使用者在使用框架学习，只需调用API，不需要理解内部工作细节，也无需理解源码，给定正确的输入后就能得到预期的输出结果，可以更快的助推自己的想法落地。而深度学习的应用涉及多种场景，因此深度学习框架的API越丰富越鲁棒，也代表着框架的易用性越强，适用性越广泛。

作业4-2：

Python模型与飞桨模型在结构上都可分为数据预处理、网络模型搭建、目标函数和优化算法配置、模型训练和保存5个部分。由于采用飞桨提供的封装函数，飞桨的代码可读性更好、配置和调用也更改简单，易用性非常好。由于有底层框架支持，飞桨模型的训练速度更快，获得训练的结果也更好。

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

判断肿瘤的良恶性问题。假设是否是恶性肿瘤F=ax+by+cz，参数是肿瘤的大小权重（a）表面是否光滑权重（b）是否疼痛权重（c）,优化目标是，让分类结果与真实结果之间误差最小。

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

目前的发展环境中AI应用于工业、医疗、服务业等各方各面。未来对AI工程师的需求会持续上升，而当前合格的AI工程师人数远远达不到市场需求，未来的发展一定会对AI工程师的需求猛增。

作业4-2：

共同点：流程一致，数据-模型-目标及优化-保存-评估

不同点：paddle封装了大量的底层代码，更快捷方便的调用api，更多的精力放在模型和调优上，而不是重复的底层开发

作业4-2：

无论是使用飞浆框架还是自己用python编写房价预测，都需要首先导入数据，处理数据，都需要定义损失函数，优化函数，学习率等。只不过通过Python编写房价预测，自己实现损失函数的定义和编写，以及优化函数实现等问题，过程繁琐，容易出错，并且自己写的代码也很难在效率上胜过飞浆框架编写的效率，使用飞浆编写神经网络模型只需要注重模型的结构设计和网络的配置，而无需编写复杂的底层实现，飞浆都给实现好了，只需要调用就好了，大大降低了模型实现的门槛，极大的提高了代码的编写效率，在成本和效率上都十分可观。使用飞浆编写神经网络模型，步骤清楚，一般步骤为数据处理、模型设计(网络结构、损失函数)、训练配置(优化函数、资源配置)、训练过程、模型的保存和加载。程序结构清楚，编写难度较使用python实现细节容易很多。对于模型的预测效果来说，理论上只要使用python自己编写的代码没有错误，和使用飞浆编写的预测效果应该差不多，只是效率可能有所不同。尤其是模型越复杂，越能体现出使用飞浆框架的效率之高。代码的效率和质量直接决定了模型运行的耗时时间。飞浆框架都是经过长时间不断打磨出来的，经过各种检验的，而且我相信编写的飞浆框架的大佬水平一定很高，在效率上我们使用python编写的也很难超过，所以使用飞浆框架应该会更加高效性，在相同的硬件配置情况下，对于较复杂的模型来说，耗时也相对较少。此外使用飞浆编写的代码可读性也会更好一些。

作业4-2：

python编写的模型最直观的感受是需要大量的工作考虑整个流程，包括数据预处理，网络模型搭建，优化算法，模型训练，模型保存推理等等。整个流程容易出错，而且需要较深的理论和实践基础。但有个好处是，能深入理解整个流程的各个细节，学习阶段比较适用，但是要工作阶段就效率太低下了。PaddlePaddle已经把相关基础工作都已经做好，而且做了基于训练实践的优化，非常有利于项目生产落地。

作业4-2：（借鉴楼上，多谢）

相同点：无论是使用飞浆框架还是自己用python编写房价预测，都需要首先导入数据，处理数据，都需要定义损失函数，优化函数，学习率等。

不同点：只不过通过Python编写房价预测，自己实现损失函数的定义和编写，以及优化函数实现等问题，过程繁琐，容易出错，并且自己写的代码也很难在效率上胜过飞浆框架编写的效率，使用飞浆编写神经网络模型只需要注重模型的结构设计和网络的配置，而无需编写复杂的底层实现，飞浆都给实现好了，只需要调用就好了，大大降低了模型实现的门槛，极大的提高了代码的编写效率，在成本和效率上都十分可观。

使用飞浆编写神经网络模型，步骤清楚，一般步骤为数据处理、模型设计(网络结构、损失函数)、训练配置(优化函数、资源配置)、训练过程、模型的保存和加载。程序结构清楚，编写难度较使用python实现细节容易很多。对于模型的预测效果来说，理论上只要使用python自己编写的代码没有错误，和使用飞浆编写的预测效果应该差不多，只是效率可能有所不同。尤其是模型越复杂，越能体现出使用飞浆框架的效率之高。代码的效率和质量直接决定了模型运行的耗时时间。飞浆框架都是经过长时间不断打磨出来的，经过各种检验的，而且我相信编写的飞浆框架的大佬水平一定很高，在效率上我们使用python编写的也很难超过，所以使用飞浆框架应该会更加高效性，在相同的硬件配置情况下，对于较复杂的模型来说，耗时也相对较少。此外使用飞浆编写的代码可读性也会更好一些。

作业4-1：

1.运行效果相同。如下图

3. 基于飞浆编写的程序更简洁，运算速度更快。

作业4-2： 基于飞浆框架编写的程序更简洁，运算速度更快。 很多程序段的功能仅需几行甚至一行代码就可以实现，这归因于框架对诸多常用功能的模块化，使得编程不再是一行行的独自编写，而变成了根据需求调用不同的函数，这使得用方可以更快速的完成编程，且易于新手使用。一个问题可以使用不同的方法来处理，这取决于每个人对问题的理解角度，飞浆框架是通过诸多资深程序员研发出的各函数模块构成的，在程序简洁、运算速度等方面远远优于单一程序员或单一团队进行的程序编写。目前全球AI领域发展迅速，诸多框架的竞争异常激烈，希望飞浆能成为其中翘楚。

作业4-2：

共同点：基本流程一致，都为数据处理，建立网络模型（超参设置），优化目标设定，训练，测试

不同点：paddle封装了大量的底层代码，使用更便捷，适合更快的网络搭建和参数优化