12.12 作业

（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()

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

答：

      本质上最小二乘法就是一种机器学习模型，典型的监督学习；最小二乘法的目的就是找出一组点的拟合线，要求所有点到拟合线的误差的平方和最小。

       根据上面的分析可知，对于直线的最小二乘法而言：

       假设：拟合点在空间分布上满足线性条件，能够用直线进行拟合；

       参数：最小二乘法的参数就是拟合直线的斜率以及截距；

       优化目标：保证所有拟合点到拟合直线的误差的平方和最小。

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

答：

      当前时代是飞速发展的信息化时代，网络化、数据化和智能化将成为这个时代的符号。随着产业结构的不断升级推进，未来传统行业的创新能力将在产业互联网的推动下得到进一步释放，一些附加值比较低的传统岗位也将陆续被智能体（人工智能产品）所取代，这些都将会促进人才结构的升级。身处这个智能化时代，只有紧跟时代步伐，不断契合时代需求的现代职场人才能够不断适应职场发展的需要，才能够手执利器成为行业执牛耳者，AI工程师就是这种手执利器的英雄。因此AI工程师是很有发展前景的。

      从经济学角度而言，这个飞速发展的信息化时代需要越来越多高精尖的人才，AI工程师无疑是推动这个信息化社会像智能化发展的人才；现在整个人工智能正在进行快速的发展和优化升级中，对高精尖的AI人才是亟需的；而目前人工智能发展只有短短几年，但已呈现井喷之势，而真正掌握屠龙利器的人相对很少；因此从市场的供需来看，需远远大于求，因此AI工程师是有发展前景的。

作业1-1

监督学习框架的用途十分广泛，在日常生活中我认为监督学习可以用来预测天气的实时变化，假设值是天气的状况，例如晴天、雨天、大雾天、下雪等等，参数有风速，风向，相对湿度，温度这些可以通过仪器简单测量所得到的数据，用来预测不久的未来，天气的情况，比如两个小时或者三个小时后。优化的目标是能尽可能的降低预测结果的误差，即如果下雨，那么雨的大小，起雾的话雾的大小等等。

作业1-2

首先就目前的行业就业情况来讲，AI工程师属于中高端人才严重缺失的职业，而且AI是一块大蛋糕，无数的厂商想要占领这块市场获取利润。再从AI的实用角度来讲，我认为发展成型的AI技术可以替代目前70%甚至以上的职业。而作为推动AI，也就是去推动历史，把人类推向未来的AI工程师，自然会有很好的待遇和发展前途

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

考研时随时间的分配

假设是考研分数与各科时间分配的量有关

参数为各科分配时间的比重

优化目标是 考研的分数

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

1.  ai的高门槛限制了入行的人数求小于供

2. ai技术迅猛发展，更需要有人去在业界去实践他

3.ai技术可以代替很多高费用请来的行业专家，因为商业的逐利性，更会有越来越多的ai工程师被引进。

p.s. 补一句 祝考研的学长学姐 成绩理想~

作业2-1

# 导入需要用到的package
import numpy as np
import json
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)
        # 第一层的参数 为了保证第二层的输入为 (1*13) 第一层的输入权重应为（13*13） （1*13） * （13*13） = (1*13)
        self.w0 = np.random.randn(num_of_weights, num_of_weights)
        self.b0 = np.zeros(num_of_weights)
        
        self.w1 = np.random.randn(num_of_weights, 1)
        self.b1 = 0.
        
    def forward0(self, x):
        x = np.dot(x, self.w0) + self.b0
        return x
    def forward1(self, x):
        x = np.dot(x, self.w1) + self.b1
        return x
    
    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 update0(self, gradient_w, gradient_b, eta = 0.01):
        self.w0 = self.w0 - eta * gradient_w
        self.b0 = self.b0 - eta * 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 train(self, x, y, iterations=100, eta=0.01):
        losses = []
        for i in range(iterations):
            out0 = self.forward0(x)
            out1 = self.forward1(out0)
            L = self.loss(out1, y)
            
            gradient_w1, gradient_b1 = self.gradient(out0, y, self.forward1(out0))
            self.update1(gradient_w1, gradient_b1, eta)
            
            gradient_w0, gradient_b0 = self.gradient(x, out0, self.forward1(x))
            self.update0(gradient_w0, gradient_b0, eta)
            
            losses.append(L)
            if (i+1) % 10 == 0:
                print('iter {}, loss {}'.format(i+1, L))
        return losses

# 获取数据
train_data, test_data = load_data()
x = train_data[:, :-1]
y = train_data[:, -1:]
# 创建网络
net = Network(13)
num_iterations=300
# 启动训练
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()

iter 10, loss 1.4710671554179553
iter 20, loss 1.1262706977242318
iter 30, loss 0.8753615146322701
iter 40, loss 0.6915425674459094
iter 50, loss 0.5558917966686835
iter 60, loss 0.45500870357646866
iter 70, loss 0.37937072082784923
iter 80, loss 0.3221842864991021
iter 90, loss 0.2785807704568637
iter 100, loss 0.2450529549354249
iter 110, loss 0.21905948400244835
iter 120, loss 0.198746737298351
iter 130, loss 0.1827528932747497
iter 140, loss 0.17006958570947628
iter 150, loss 0.15994395886116639
iter 160, loss 0.15180908612161478
iter 170, loss 0.14523432233266145
iter 180, loss 0.1398896855234024
iter 190, loss 0.13552013643760388
iter 200, loss 0.13192686893971053
iter 210, loss 0.12895359681796806
iter 220, loss 0.126476431130197
iter 230, loss 0.12439636372104511
iter 240, loss 0.1226336619420209
iter 250, loss 0.12112367708133463
iter 260, loss 0.11981370442367957
iter 270, loss 0.11866063145800476
iter 280, loss 0.117629216205905
iter 290, loss 0.11669116490475274
iter 300, loss 0.11582721015870952

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

答：1. 监督学习的例子很多，比如说某人的午饭饭量，

假设是饭量与这些相关因素有某种非线性关系：气温，喝水杯数，运动时间，等

参数如上

优化目标，通过今日某人的活动预测他今中午饭量

2.发展前景是必须有的，有一个重要的客观因素是社会进入了数据化社会，人们的生活与数据息息相关，那么商业也是通过数据分析得到更好的发展，制定公司的营业策略等等，政府通过基本数据更好的了解人民需求和生活状态，社会能够更加和谐稳定，并且技术的发展需要的大量的人才。AI在这其中扮演的角色分量之重不言而喻，但是现实情况是大多数人并不从事AI或者了解不多，不能够在这个方向进行深入的探究和发展，那么专业的人才越少，越需要这方面人才的加入，发展前景有，就看个人能不能发展进去了。

作业1-2：

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

牛顿第二定律是一个线性函数的拟合问题，假设是物体受到的力和物体的加速度之间符合线性关系。生活中这样的监督学习的问题有：预测一个人的身高。假设一个人的身高与各种影响因素之间是线性关系，参数有其父母的身高、营养条件、睡眠情况、运动情况等。优化目标是使得预测的身高和真实的身高之间的均方误差最小。

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

AI工程师的出现和发展与机器学习和深度学习理论的发展、计算机算力的发展、以及互联网大数据的发展密不可分。未来在电商平台、工业制造、医疗图像、无人驾驶等领域，AI技术都将发挥巨大的作用。目前求职市场中，AI工程师竞争激烈，但是从我搜集到的情况来看，符合条件的AI工程师却是紧缺人才。因此，AI工程师具有很大的发展前景，同时也具有很高的门槛。但是，只有有扎实的知识和强大的工程能力，AI工程师在市场上仍是抢手的人才。

作业1-2：

（1）海拔与温度的关系预测。假设：温度随海拔高度是梯度发生变化。参数是高度和温度。优化目标是温度随海拔高度的变化。

（2）AI工程师很有前景的原因：1、AI在很多领域已经得到了很好的应用（如，人脸识别，目标检测等），导致其他行业纷纷想加入AI的热潮，如现在的AI医疗，无人驾驶等等，某种意义上说，AI使互联网迈入了一个新的方向。2、AI的未来无限可能，传统领域的工作者纷纷加入AI的工作中，点燃了AI的激情。

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

家里宠物体重、运动量与饭量的关系。

假设为线性关系。

参数是宠物的体重及运动量

优化目标是提供的食物能刚好满足宠物的需求
②为什么说AI工程师有发展前景？怎样从经济学（市场供需）的角度做出解读？

AI可以助力工业升级，解决需要耗费大量人力资源的工作，降低人力成本

作业1-2
1
通过片子看是否得癌症的几率
输入是片子图片
输出是是否得癌症

2 俗话说物以稀为贵，从供需关系来说，现在供应小于需求时，所以说有发展前景，当供应大于需求时，前景就不是很明朗了。

12.12

作业2-1（1）

作业2-1:

作业2-1:

作业2-1：

（1）

（2）只要修改这个类即可

class Regressor(fluid.dygraph.Layer):
    def __init__(self, name_scope):
        super(Regressor, self).__init__(name_scope)
        name_scope = self.full_name()
        # 定义两层层全连接层，输出维度是1，激活函数为None，即不使用激活函数
        self.fc = FC(name_scope, size=1, act=None)
        self.fcc = FC(name_scope, size = 13, act=None)  #添加的隐层
    
    # 网络的前向计算函数
    def forward(self, inputs):
        x = self.fcc(inputs)   #隐层
        x = self.fc(x)         #输出层
        return x