作业2-1：

（2），只需要前向计算多一层，然后反向更新参数多一步即可

计算机视觉分类

作业2-1 基础题

作业1-2：

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

答：通过汽车的配置来预测汽车的价格。假设汽车的价格，参数是安全配置、科技配置、发动机、变速箱、内饰、舒适度等，优化目标是汽车的预测价格。

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

答：2017年3月5日“人工智能”正式写入2017政府工作报告，崭新的时代来了！无人驾驶、个人助理、金融、电商、医疗、教育等各大耳熟能详的领域，人工智能都已经开始进入。预计2030年人工智能将造就七万亿美元规模的大市场，而人工智能工程师（简称AI工程师）人才就是人工智能七万亿市场的重要基石！

作业2-1

提高题：

import numpy as np

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.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

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

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

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

作业2-1

基础题：

numpy广播分享：

1.矩阵与数值相加，矩阵中的每一个值与该数值相加，形成一个与原矩阵维度一致的矩阵

2.列数相同，行数不同的矩阵相加，将少行的矩阵按行复制，形成与多行矩阵相同的维度，再按两矩阵对应位置上的数值相加

3.行数相同，列数不同的矩阵相加，将少列的矩阵按列复制，形成与多列矩阵相同的维度，再按两矩阵对应位置上的数值相加

以上不止适合加法运算，减、乘、除等数学运算同样适用

作业：2-1

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

答：猪肉价格与客户的购买量可以用监督学习框架来预测：猪肉价格x,购买量y，两者是反比例关系，y=1/x+b； 参数：为k，

优化目标：是找出能拟合所有观测样本的最优k与b

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

当前各行业都在与AI技术相融合，AI的应用领域非常广泛，加之全民AI的普及意味着与计算机打交道不再只是CS专业该干的事情，也是各领域都应该发挥专长参与进来，更强调跨领域跨学科，市场前景广阔。

作业2.1

挑战题：

方法一：网络结构用列表构建，但是在计算损失值的时候会出现一个问题，一开始loss稳步下降，但是到中途突然变为nan，而且模型一些地方计算的时候很容易出现值为nan的情况，不是很清楚其中的原因，但是计算的逻辑上应该是没有问题的。希望老师能帮忙解答一下这个问题

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

    # 训练集和测试集的划分比例
    # ratio = 0.8
    # offset = int(data.shape[0] * ratio)
    training_data = data[:offset]
    test_data = data[offset:]
    return training_data, test_data


def rand(a, b):
    return (b - a) * random.random() + a


def make_matrix(m,n,fill=0.0):
    mat = []
    for i in range(m):
        mat.append([fill] * n)
    return mat


class BPNeuralNetwork:

    def __init__(self):
        self.input_n = 0
        self.hidden_n = 0
        self.output_n = 0
        self.input_cells = []
        self.hidden_cells = []
        self.output_cells = []
        self.input_weights = []
        self.output_weights = []

    def setup(self, ni, nh, no):
        self.input_n = ni + 1
        self.hidden_n = nh
        self.output_n = no

        self.input_cells = [1.0] * self.input_n
        self.hidden_cells = [1.0] * self.hidden_n
        self.output_cells = [1.0] * self.output_n

        self.input_weights = make_matrix(self.input_n,self.hidden_n)
        self.output_weights = make_matrix(self.hidden_n,self.output_n)

        # random activate
        for i in range(self.input_n):
            for h in range(self.hidden_n):
                self.input_weights[i][h] = rand(-0.2, 0.2)
        for h in range(self.hidden_n):
            for o in range(self.output_n):
                self.output_weights[h][o] = rand(-0.2, 0.2)

    def predict(self, inputs):
        for i in range(self.input_n - 1):
            self.input_cells[i] = inputs[i]

        for j in range(self.hidden_n):
            total = 0.0
            for i in range(self.input_n):
                total += self.input_cells[i] * self.input_weights[i][j]
            self.hidden_cells[j] = total

        for k in range(self.output_n):
            total = 0.0
            for j in range(self.hidden_n):
                total += self.hidden_cells[j] * self.output_weights[j][k]
            self.output_cells[k] = total

        return self.output_cells[:]

    def back_propagate(self,case,label,learn):

        self.predict(case)
        # 计算输出层的误差
        output_deltas = [0.0] * self.output_n
        for k in range(self.output_n):
            error = label[k] - self.output_cells[k]
            output_deltas[k] = self.output_cells[k] * error

        # 计算隐藏层的误差
        hidden_deltas = [0.0] * self.hidden_n
        for j in range(self.hidden_n):
            error = 0.0
            for k in range(self.output_n):
                error += output_deltas[k] * self.output_weights[j][k]
            hidden_deltas[j] = self.hidden_cells[j] * error

        # 更新输出层权重
        for j in range(self.hidden_n):
            for k in range(self.output_n):
               self.output_weights[j][k] += learn * output_deltas[k] * self.hidden_cells[j]

        # 更新隐藏层权重
        for i in range(self.input_n):
            for j in range(self.hidden_n):
                self.input_weights[i][j] += learn * hidden_deltas[j] * self.input_cells[i]

        error = 0
        for o in range(len(label)):
            error += 0.5 * (label[o] - self.output_cells[o]) ** 2

        return error

    def train(self,cases,labels,limit=100,learn=0.05):
        loss = list()
        for j in range(limit):
            error = 0
            for i in range(len(cases)):
                label = labels[i]
                case = cases[i]
                error += self.back_propagate(case, label, learn)
            loss.append(error)
            print("iter:", j, "loss: ", error)
        return loss

    def test(self):
        train_data, test_data = load_data()
        x = train_data[:, :-1]
        y = train_data[:, -1:]

        cases = x.tolist()
        labels = y.tolist()

        self.setup(13, 13, 1)
        num_iterations = 200
        losses = self.train(cases, labels, num_iterations, 0.05)
        plot_x = np.arange(num_iterations)
        plot_y = np.array(losses)
        plt.plot(plot_x, plot_y)
        plt.show()


if __name__ == '__main__':
    nn = BPNeuralNetwork()
    nn.test()

、

方法二：网络结构使用numpy.array数据类型，有效解决方法一出现的状况

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

    # 训练集和测试集的划分比例
    # ratio = 0.8
    # offset = int(data.shape[0] * ratio)
    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.w0 = np.random.randn(num_of_weights, num_of_weights)
        self.b0 = np.zeros((1, num_of_weights))
        self.w = np.random.randn(num_of_weights, 1)
        self.b = 0.

    def forward(self, x):
        z = np.dot(np.dot(x, self.w0) + self.b0, self.w) + self.b
        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)
        gradient_w = (z - y) * (np.dot(x, self.w0) + self.b0)
        gradient_w = np.mean(gradient_w, axis=0)
        gradient_w = gradient_w[:, np.newaxis]
        gradient_b = (z - y)
        gradient_b = np.mean(gradient_b)
        return gradient_w, gradient_b

    def gradient_2(self, x, y):
        z = self.forward(x)
        gradient_w = np.dot((z - y), np.transpose(self.w)) * x
        gradient_w = np.mean(gradient_w, axis=0)
        gradient_w = gradient_w[:, np.newaxis]
        gradient_b = np.dot((z - y), np.transpose(self.w))
        gradient_b = np.mean(gradient_b)
        return gradient_w, gradient_b

    def update(self, gradient_w, gradient_b, eta=0.01):
        self.w = self.w - eta * gradient_w
        self.b = self.b - eta * gradient_b

    def train(self, x, y, iterations=100, eta=0.01):
        losses = []
        for i in range(iterations):
            z = self.forward(x)
            L = self.loss(z, y)
            gradient_w, gradient_b = self.gradient(x, y)
            self.update(gradient_w, gradient_b, eta)

            gradient_w_2, gradient_b_2 = self.gradient_2(x, y)
            self.update(gradient_w_2, gradient_b_2, eta)

            losses.append(L)
            if (i + 1) % 10 == 0:
                print('iter {}, loss {}'.format(i, L))
        return losses


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

print(x.shape)
# 创建网络
net = Network(13)
num_iterations = 1000
# 启动训练
losses = net.train(x, y, iterations=num_iterations, eta=0.01)

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

12月10日作业
作业1-2：完成下面两个问题，并将答案发布在帖子下面
①类比牛顿第二定律的案例，在你的工作和生活中还有哪些问题可以用监督学习的框架来解决？假设和参数是什么？优化目标是什么？

  预测饮品店的当日销量。使用多元线性假设，认为有多个因素与当日销量之间的关系为线性关系，参数有：天气温度、是否假日、人流量、员工数、饮品种类、是否外卖。优化目标可设定为均方误差作为损失函数，找出此函数的最小值即为最优目标。

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

  目前的AI落地项目从自动驾驶汽车、预测分析应用程序、人脸识别，到聊天机器人、虚拟助手、认知自动化和欺诈检测等各方面都已有很多的实际用例。AI在各行各业的应用趋势发展非常迅速，这将会不停的产⽣更多的AI工程师职位需求。

作业2-1（1）基础题

作业2-1：（1）基础题

作业1-2：

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

采集3轴运动加速传感器数据判断人的动作（跑步，正常行走，静坐）可以用监督学习框架，假设传感器采集的数据是输入x，不同动作是输出y，y=W*x+b ,通过大量实验数据的训练得到w，b的值，当已知数据时可以在移动设备上判断动作。

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

很人都在用ai，经济学太复杂了

12月10日作业

作业1-2：完成下面两个问题，并将答案发布在帖子下面
①类比牛顿第二定律的案例，在你的工作和生活中还有哪些问题可以用监督学习的框架来解决？假设和参数是什么？优化目标是什么？
②为什么说AI工程师有发展前景？怎样从经济学（市场供需）的角度做出解读？

①在垃圾邮件判断中，假设是垃圾邮件与它对应的类之间的关系，参数是对垃圾邮件的各方面判断指标设定的加权系数，优化目标是尽可能的区分出邮件中的垃圾邮件。

②AI工程师所掌握的技术跟建筑，教育，交通，金融，医疗等相关的专业领域都有非常紧密的结合，AI工程师技术的应用非常广泛。随着AI跨学科在交叉领域中的应用越来越广，各行各业都广泛应用着AI技术。

挑战题：2-2

作业2-1（12月12日作业）

（1）基础题：填写购买苹果和橘子的梯度传播

（2）挑战题：用代码实现两层的神经网络的梯度传播，中间层的尺寸为13

代码(主要部分)

class Network(object):
    def __init__(self, num_of_weights):
        # 随机产生w的初始值
        # 为了保持程序每次运行结果的一致性，此处设置固定的随机数种子
        #np.random.seed(0)
        self.w1 = np.random.randn(num_of_weights, num_of_weights)
        self.b1 = np.zeros((1, num_of_weights))
        
        self.w2 = np.random.randn(num_of_weights, 1)
        self.b2 = 0.
        
    def forward(self, x, w, b):
        # z = np.dot(x, self.w1) + self.b1
        z = np.dot(x, w) + b
        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, z, x, y):
        # z = self.forward(x, self.w1, self.b1)
        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 update(self, w, b, gradient_w, gradient_b, eta=0.01):
        w = w - eta * gradient_w
        b = b - eta * gradient_b
        return w, b
    
    def my_model(self, x, y, eta=0.01, flag_train=1):
        net1 = self.forward(x, self.w1, self.b1)
        net2 = self.forward(net1, self.w2, self.b2)
        loss = self.loss(net2, y)
        
        if flag_train == 1:
            gradient_w2, gradient_b2 = self.gradient(net2, net1, y)
            self.w2, self.b2 = self.update(self.w2, self.b2, gradient_w2, gradient_b2, eta)
            gradient_w1, gradient_b1 = self.gradient(net1, x, y)
            # print(gradient_w1.shape)
            self.w1, self.b1 = self.update(self.w1, self.b1, gradient_w1*self.w2, gradient_b1*self.b1, eta)
        return loss
                
    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:]
                loss = self.my_model(x, y, eta)
                losses.append(loss)
                print('Epoch {:3d} / iter {:3d}, loss = {:.4f}'.format(epoch_id, iter_id, loss))
                
        return losses
        
    def test(self, test_data, flag_train=0):
        x = test_data[:,:-1]
        y = test_data[:,-1:]
        loss = self.my_model(x, y, flag_train)
        print('Test loss : {:.4f}'.format(loss))

结果：（训练）

12月10日作业，作业1-2：

①手术器材识别问题。医生用完手术器材后需要及时归类，这是就需要对器材进行图像分类，可以用监督学习的框架来解决。以使用AlexNet为例，假设是8层神经网络，参数是卷积层与全连接层的权重，优化目标是降低测试数据与真值标记的loss值，在避免过拟合的情况下，使模型收敛到一个较好的效果的点上。

②正是由于近些年算力与数据量的不断提升，深度学习算法工程师可以通过构造有效的模型来解决真实世界中的实际问题，带来客观的经济价值，从而刺激市场，使供不应求，给广大的数据科学爱好者带来了劳动市场的契机。