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

天气预报、股价预测、收入预测问题可以用监督学习的框架来解决。

假设为一个人的收入与职位名称、经验年限、位置、教育水平有关

参数为其职位名称、经验年限、位置、教育水平等

优化目标为尽可能的降低预测结果的误差

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

现在是第3次AI行业革命，最火爆的行业是人工智能，国家政策也支持相关行业发展。

这一年，对于人工智能相关人才需求的增长净增一倍！不少企业在追逐人才时出现高薪难求的状况。

AI工程师行业存在人才缺口，供不应求，因此具有极大发展前景。

你只求出了W2，b2的梯度，并没求出W1,b1的梯度

作业2-1：

作业2-1:

作业1-2：

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

答：预测PM2.5，假设 Y = SUM(Wi * Xi) + b，X = [hour（日内小时）、dewp（露点）、temp（气温）、pres（气压）、cbwd（风向）、lws（风速）、ls（累积降雪）、lr（累积降雨）]，Xi为对应数据，Wi为对应权重，b为偏置项，优化目标：预测某日的PM2.5值

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

答：人工智能现在广泛地受到社会各个阶层的关注，这不仅是因为AI对社会产生地深远地影响，也是因为人们能从AI身上看到社会生产力和生产方式的下一次革命，现如今AI落地的产品也越来越多，包括面部识别支付、面部识别认证、车牌识别、CT图像诊断等等，那么AI工程师的需求也就不言而喻了。从市场供需方面看，目前很多公司不管本身是不是计算机行业，都有可能成立人工智能研究院或者相应的项目部（比如汽车制造公司就会成立自动驾驶研究院），现在的人工智能火得都要糊了，所以AI工程师的需求无疑是巨大的，但是公司又极其看重AI工程师的学术和工程能力，虽然合格的AI工程师市场是亟需的，但是所谓合格就需要有扎实的理论算法基础，仅仅会使用一两个算法框架，而对算法一知半解是远远不够的。

作业2-2：

前向传播代码如下，但是后向传播不知道如何实现。

作业2-1

import numpy as np

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

def forward1(self, x):
z = np.dot(x, self.w1) + self.b1
return z

def forward2(self, x):
z = np.dot(x, self.w2) + self.b2
return z

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):
N = x.shape[0]
gradient_w = 1. / N * np.sum((z-y) * x, axis=0)
gradient_w = gradient_w[:, np.newaxis]
gradient_b = 1. / N * np.sum(z-y)
return gradient_w, gradient_b

def update1(self, gradient_w, gradient_b, eta = 0.01):
self.w1 = self.w1 - eta * gradient_w
self.b1 = self.b1 - eta * gradient_b

def update2(self, gradient_w, gradient_b, eta = 0.01):
self.w2 = self.w1 - eta * gradient_w
self.b2 = self.b1 - eta * gradient_b

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:]
a1 = self.forward1(x)
a = self.forward2(a1)
loss = self.loss(a, y)
#gradient_w, gradient_b = self.gradient(x, y)
#self.update(gradient_w, gradient_b, eta)
gradient_w2, gradient_b2 = self.gradient(out0, y, self.forward1(a1))
self.update2(gradient_w2, gradient_b2, eta)

gradient_w1, gradient_b1 = self.gradient(x, a1, self.forward1(x))
self.update0(gradient_w1, gradient_b1, eta)
losses.append(loss)
print('Epoch {:3d} / iter {:3d}, loss = {:.4f}'.
format(epoch_id, iter_id, loss))

return losses

作业1-2：

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

对疾病的大概诊断可以通过监督学习来解决，假设从身体的各种测量指标到疾病的诊断是一个非常复杂的函数，这个函数参数是各项指标对各种疾病的影响程度，优化目标就是使训练出来的系统的预测值不断地接近实际的诊断。
②为什么说AI工程师有发展前景？怎样从经济学（市场供需）的角度做出解读？

现在AI大热，因此对AI产业相关的人才的需求量增大，加之AI工程师是AI产业建设不可或缺的基础人才，所以发展前景广阔。

作业2-1：

（1）

（2）

import numpy as np
from matplotlib import pyplot as plt
def sigmoid(x):
    s = 1 / (1 + np.exp(-x))
    return s


def load_data():
    # 从文件导入数据
    datafile = '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):
        #print(maximums[i], minimums[i], avgs[i])
        data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i])

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

class Network(object):
    def __init__(self, num_of_weights):
        self.w1 = np.random.randn(13,13)
        self.b1 = np.random.randn(13,1)
        self.w2 = np.random.randn(1,13)
        self.b2 = 0.0

train_data, test_data = load_data()
x = train_data[:, :-1].T
y = train_data[:, -1:].T
net = Network(13)
k=0.1
losses = []
for g in range(1,1000):
    #正向传播
    z1=np.dot(net.w1,x)+net.b1
    a1=sigmoid(z1)#使用sigmoid作为激活函数
    z2=np.dot(net.w2,a1)+net.b2
    a2=sigmoid(z2)#使用sigmoid作为激活函数
    #反向传播
    dz2=a2-y
    dw2=1/404*(np.dot(dz2,a1.T))
    db2=1/404*(np.sum(dz2,axis=1,keepdims=True))
    dz1=np.dot(net.w2.T,dz2)*y*(1-y)
    dw1=1/404*(np.dot(a1,x.T))
    db1=1/404*(np.sum(dz1,axis=1,keepdims=True))
    # #参数更新
    net.w1=net.w1-k*dw1
    net.w2=net.w2-k*dw2
    net.b1=net.b1-k*db1
    net.b2=net.b2-k*db2
    C=-y*np.log(a2)-(1-y)*np.log(1-a2)
    print(1/404*np.sum(C))
    losses.append(1/404*np.sum(C))

plot_x = np.arange(len(losses))
plot_y = np.array(losses)
plt.plot(plot_x, plot_y)
plt.ylabel('Loss')
plt.xlabel("Iterations")
plt.show()

作业2-1 挑战题（对于不含激活函数的1层和2层神经网络可以顺利运行，3层对于求导仍然存在问题）待下次解决，

# 多层神经网络，不含激活函数
import numpy as np
import matplotlib.pyplot as plt
def load_data():
    # 从文件导入数据
    datafile = './work/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):
        #print(maximums[i], minimums[i], avgs[i])
        data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i])

    # 训练集和测试集的划分比例
    training_data = data[:offset]
    test_data = data[offset:]
    return training_data, test_data
class Network(object):
    def __init__(self, num_of_weights):
        # 随机产生w的初始值
        # 为了保持程序每次运行结果的一致性，此处设置固定的随机数种子
        np.random.seed(0)
        self.w=[]
        self.b=[]
        if isinstance(num_of_weights, int): #此处判断是否为数字，
            num_layers = np.array([num_of_weights])
        else:
            num_layers = np.array(num_of_weights)
        self.layers = len(num_layers)
        for x in range(self.layers):
            if x<(self.layers-1):
                self.w.append(np.random.randn(num_layers[x+1], num_layers[x]))
                self.b.append(np.zeros(num_layers[x+1]))
            else:
                self.w.append(np.random.randn(1, num_layers[x]))
                self.b.append(np.array([0]))
        
    def forward(self, x):
        pred = []
        for ex in x:
            z = ex
            for i in range(self.layers):
                z = np.dot(self.w[i], z) + self.b[i] 
            pred.append(z)
        return pred
    
    def loss(self, z, y):
        error = z - y
        # print(error.shape)
        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_w = [None]*self.layers
        gradient_b = [None]*self.layers
        x_in_list = [x]
        for layer in range(self.layers-1):
            x_in=[]
            for ex in x_in_list[layer]:
                x_in.append(np.dot(self.w[layer], ex)+self.b[layer])
            x_in_list.append(x_in)
        gradient_w[self.layers-1] = 1. / N * np.sum((z-y)*x_in_list[self.layers-1], axis=0)
        gradient_b[self.layers-1] = 1. / N * np.sum(z-y)
        # 逆向传播
        dot_w = self.w[self.layers-1]
        for layer in range(self.layers-2, -1, -1):
            # 超过3层神经网络后需要计算的导数，此处仍存在问题，需要解决
            if layer

# 多层神经网络，不含激活函数
import numpy as np
import matplotlib.pyplot as plt
def load_data():
    # 从文件导入数据
    datafile = './work/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):
        #print(maximums[i], minimums[i], avgs[i])
        data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i])

    # 训练集和测试集的划分比例
    training_data = data[:offset]
    test_data = data[offset:]
    return training_data, test_data
class Network(object):
    def __init__(self, num_of_weights):
        # 随机产生w的初始值
        # 为了保持程序每次运行结果的一致性，此处设置固定的随机数种子
        np.random.seed(0)
        self.w=[]
        self.b=[]
        if isinstance(num_of_weights, int): #此处判断是否为数字，
            num_layers = np.array([num_of_weights])
        else:
            num_layers = np.array(num_of_weights)
        self.layers = len(num_layers)
        for x in range(self.layers):
            if x<(self.layers-1):
                self.w.append(np.random.randn(num_layers[x+1], num_layers[x]))
                self.b.append(np.zeros(num_layers[x+1]))
            else:
                self.w.append(np.random.randn(1, num_layers[x]))
                self.b.append(np.array([0]))
        
    def forward(self, x):
        pred = []
        for ex in x:
            z = ex
            for i in range(self.layers):
                z = np.dot(self.w[i], z) + self.b[i] 
            pred.append(z)
        return pred
    
    def loss(self, z, y):
        error = z - y
        # print(error.shape)
        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_w = [None]*self.layers
        gradient_b = [None]*self.layers
        x_in_list = [x]
        for layer in range(self.layers-1):
            x_in=[]
            for ex in x_in_list[layer]:
                x_in.append(np.dot(self.w[layer], ex)+self.b[layer])
            x_in_list.append(x_in)
        gradient_w[self.layers-1] = 1. / N * np.sum((z-y)*x_in_list[self.layers-1], axis=0)
        gradient_b[self.layers-1] = 1. / N * np.sum(z-y)
        # 逆向传播
        dot_w = self.w[self.layers-1]
        for layer in range(self.layers-2, -1, -1):
            # 超过3层神经网络后需要计算的导数，此处仍存在问题，需要解决
            if layer

        for layer in range(self.layers-2, -1, -1):
            # 超过3层神经网络后需要计算的导数，此处仍存在问题，需要解决
            if layer

作业2-1 基础题

作业1-2：

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

天气预测。

参数是各种可能影响气候变化的变量。优化目标是尽量使预测与实际情况拟合。

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

Ai与在很多领域都已经得到了很好的应用，包括人脸识别、预测预警等，这使得ai与更多行业领域结合成为可能，市场需求量巨大。

作业1-2：①类比场景--医疗疾病诊断， 假设及参数--使用病人的体检化验结果作为参数，输入诊断模型。 优化目标--使模型诊断更准确。

                 ②人类工业发展的过程就是解放人类双手（或者说对于重复劳动用机器代替人类）的过程，而AI就是实现这一目标的终极方                           案，  所以未来世界必然是人工智能的世界。所以对于市场需求来说不仅在经济上，任何领域都是这样的发展趋。

作业2-1：

作业2-1
（1）基础题

（2）挑战题
第一层的反向传播需要用到三维numpy数组

import numpy as np
import matplotlib.pyplot as plt

filepath = "housing.data"
data = np.fromfile(filepath, sep=" ")
data = data.reshape(data.shape[0]//14, 14)

train_ratio=0.8
offset=int(train_ratio*len(data))
training_data = data[:offset,...]
testing_data = data[offset:,...]

training_data_mean = np.mean(training_data, axis=0)
training_data_max = np.max(training_data, axis=0)
training_data_min = np.min(training_data, axis=0)
training_data = (training_data-training_data_mean) / \
    (training_data_max-training_data_min)
testing_data = (testing_data-training_data_mean) / \
    (training_data_max-training_data_min)

training_data_x = training_data[..., :-1]
training_data_y = training_data[..., -1:]


class Network_2_level(object):
    def __init__(self, inputs=13, midlevel_pro_number=13):
        np.random.seed(0)
        # 1st level
        self.w_1 = np.random.randn(
            inputs, midlevel_pro_number)    # axis_0: input_id; axis_1: percetron_id_ofLevel-1
        self.b_1 = np.zeros(inputs) # 1-D vector, all-in-one
        # 2nd level
        self.w_2 = np.random.randn(inputs, 1)   # axis_0: input_id; axis_1: percetron_id_ofLevel-2 (only 1)
        self.b_2 = 0    # 1-D vector, all-in-one (single)
        # self.b_2 = np.random.randn(1)

    def forward(self, x):
        self.y_1 = self.x_2 = np.dot(x, self.w_1)+self.b_1  # Output of level-1 & input of level-2. Axis_0: sample_id; axis_1: percetron_id
        self.z = np.dot(self.x_2, self.w_2) + self.b_2  # Output of level-2. Axis_0: sample_id; axis_1: percetron_id (only 1)
        return self.z

    def loss(self, x, y):
        '''
        x: axis_0: sample_id; axis_1: feature_id
        y: axis_0: sample_id; axis_1: result_id (only 1)
        '''
        z = self.forward(x)
        self.cost = np.mean((z-y)**2)
        return self.cost

    def gradient(self, x, y):
        self.loss(x, y)
        gradient_w_2 = np.mean((self.z-y) * self.x_2,  axis=0)[..., np.newaxis] # axis_0: sample; axis_1: w_id
        gradient_b_2 = np.mean(self.z-y)    # vector (only element)
        gradient_w_1 = np.mean(
            x[:, np.newaxis, :] * self.w_2 * (self.z-y)[:, np.newaxis, :], axis=0) # axis_0: sample_id; axis_1: percetron_id; axis_2: feature_id/input_id
        gradient_b_1 = np.mean((self.z-y) * self.w_2.T, axis=0) # vector
        return gradient_w_2, gradient_b_2, gradient_w_1, gradient_b_1

    def update(self, gradient_w_1, gradient_b_1, gradient_w_2, gradient_b_2, eta=0.01):
        self.w_1 = self.w_1-eta*gradient_w_1
        self.b_1 = self.b_1-eta*gradient_b_1
        self.w_2 = self.w_2-eta*gradient_w_2
        self.b_2 = self.b_2-eta*gradient_b_2

    def train(self, training_data, num_epoches, batch_size=10, eta=0.01):
        losses=[]
        for epoch_id in range(num_epoches):
            np.random.shuffle(training_data)
            batches=[training_data[k:k+batch_size] for k in range(0,training_data.shape[0],batch_size)]
            for batch_id,mini_batch in enumerate(batches):
                x=mini_batch[:,:-1]
                y=mini_batch[:,-1:]
                gradient_w_2, gradient_b_2, gradient_w_1, gradient_b_1=\
                    self.gradient(x,y)
                self.update(gradient_w_1, gradient_b_1, gradient_w_2, gradient_b_2, eta=eta)
                losses.append(self.cost)
                print('Epoch {:3d} / iter {:3d}, loss = {:.4f}'.format(epoch_id, batch_id, self.cost))
        return losses

net=Network_2_level(midlevel_pro_number=13)
losses = net.train(training_data, num_epoches=50, batch_size=100, eta=0.1)
losses=np.array(losses)
losses=losses[losses<1]
plot_x = np.arange(len(losses))
plot_y = np.array(losses)
plt.plot(plot_x, plot_y)
plt.show()

作业1-2：

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

我们的工作和生活中有很多问题都是可以用监督学习解决的，例如万有引力、电荷间相互作用力、电荷势能等。就万有引力公式来说，假设是经典力学以及物体之间的距离远远大于物体的半径，输入是物体的质量以及物体之间的距离，参数是万有引力常数，优化目标是万有引力的预测值与实际值之间的偏差最小化。

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

AI工程师发展前景比较看好的原因有以下几个方面：

1.     近几年，数据、算力的不断提升给人工智能，尤其是深度学习的发展提供了必要的基础条件，使得人工智能飞速发展；

2.     目前，人工智能的需求大于供给，人才缺口仍比较大；

3.     国家出台了一系列政策促进人工智能的发展，各个地方政府也相继采取了一系列措施加速人工智能的落地实施；

4.     现阶段，AI技术的应用还离不开专业AI工程师，还远没有达到AI取代人类工作的地步。

从市场供需的角度考虑，主要原因就是目前人工智能对于人才的需求远远大于人才的供给。

12月12日作业：

1.

2.

代码：

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

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

    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):
        #print(maximums[i], minimums[i], avgs[i])
        data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i])

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

# 获取数据
training_data, test_data = load_data()
x = training_data[:, :-1]
y = training_data[:, -1:]


class Network_two_layer(object):
    def __init__(self, num_of_weights):
        np.random.seed(0)
        self.w0 = np.random.randn(num_of_weights, 13)
        self.b0 = np.zeros((1,13))
        self.w1 = np.random.randn(13, 1)
        self.b1 = 0.
        
    def forward(self, x):
        x = np.dot(x, self.w0) + self.b0
        z = np.dot(x, self.w1) + self.b1 
        self.x1 = x
        return z
    
    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_x1 = 1. / N * np.dot((z-y),self.w1.T)
        self.gradient_w1 = 1. / N * np.dot(self.x1.T,z-y)
        self.gradient_b1 = 1. / N * np.sum(z-y)
        self.gradient_w0 = np.dot(x.T,gradient_x1)
        self.gradient_b0 = np.sum(gradient_x1,axis=0)
        self.gradient_b0 = self.gradient_b0[np.newaxis,:]
    
    def update(self, eta = 0.01):
        self.w1 = self.w1 - eta * self.gradient_w1
        self.b1 = self.b1 - eta * self.gradient_b1
        self.w0 = self.w0 - eta * self.gradient_w0
        self.b0 = self.b0 - eta * self.gradient_b0
            
                
    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

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

# 创建网络
net = Network_two_layer(13)
# 启动训练
losses = net.train(train_data, num_epoches=50, batch_size=100, eta=0.1)

# 画出损失函数的变化趋势
plot_x = np.arange(len(losses))
plot_y = np.array(losses)
plt.plot(plot_x, plot_y)
plt.show()

loss图：

作业1-2：

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

工作中目前准备做图像的超分辨重建，模型假设：一个复杂的低分辨率到高分辨率的映射函数，参数为图像各种特征值，PSNR/SSIM等等来评价

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

我认为AI工程师发展前景广阔，市场需求大而人才供应少，未来越来越多的行业都有AI落地。

一. 人才供给方面短缺：

1.AI方面高校培养出的人才数量不足，国内高校尚未有系统化培养AI工程师的方案。

2.是AI工程师需要理论和实际工程经验进行培养，毕业后需要3-5年的成熟期。

3.是AI从2012年之后迎来第三次大发展，国内从业的软件工程技术人员2016年才逐渐接触和学习AI，到今年只有3年时间，人才成熟期有一定滞后。

二.从工业界需求方面

1. 首先是工业界算力和存储资源比以前有质的飞跃，  使得AI具备土壤，能够落地到各行各业中。AI的应用领域一下成几何倍数扩大，对人才需求量猛增。

2. 当前深度神经网络在图像识别，语音识别，自然语言处理方面成果显著，特定环境中已经超越人类的处理能力。如今国内人力成本剧增的情况下，工业界希望借助AI进一步降低生产成本，提高生产效率

3.当前的AI, 特别是深度学习网络，只能解决某一特定问题，不同行业的新问题要重新建模，难以复用。AI工程师人才“复用率”低。

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

在生活中和工作中有许多的问题都可以使用监督学习的框架来实现。比如手机价格，地铁人流量，旅游景点的人流量，饭店的收入等。手机价格与手机上市时间，处理器，相机像素，个数，电池容量，外观，新型科技含量，品牌有关，优化目标就是预测与实践之间的差值尽量小。地铁和旅游景点的人流量与是否是节假日，日期时间，站台，地铁线等有关。

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

AI工程师目前是供不应求，市场需求量很大，因为目前各行各业都使用上了机器学习，人工智能等技术，各个厂商都有AI技术人才的需求，从智能驾驶，监控车流量分析，疾病分析等到农业灌溉，天气预报等需要人工智能的分析，有助于准确的分析出结果，由于对AI工程师的需求，所以现在AI工程师很有发展前景，目前AI产业还处于前期阶段，后面的晋升空间还很大。

12月12日作业