12月12日作业

（1）

（2）

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.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):
        z1 = np.dot(x, self.w0) + self.b0
        z2 = np.dot(z1, self.w1) + self.b1
        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]
        self.gradient_w1 = 1. / N * np.dot(self.z1.T, z - y) 
        self.gradient_b1 = 1. / N * np.sum(z - y) 
        gradient_z1 = 1. / N * np.dot((z - y), self.w1.T)
        self.gradient_w0 = np.dot(x.T, gradient_z1)
        self.gradient_b0 = np.sum(gradient_z1, 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(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()

作业1-2：

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

答：目标检测类别问题，假设和参数是目前的预测框的box是由预先定义的anchor box通过尺度缩放和平移得到的，优化目标就是更加准确的预测要检测目标的位置。

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

答：目前的AI技术在逐渐迈向成熟，当前有许多任务，使用深度学习的技术处理可以比传统的技术得到更好的效果，而且当前大数据时代已经来临，足以支撑AI相关技术对于海量数据的需求。目前市场上对于AI工程师的需求也是十分大，因为AI技术在各个行业领域内都可以得到比较好的效果，所以AI工程师的发展前景还是十分好的。

作业2-1：

1、基础题：

2、挑战题：

import numpy as np

# 获取数据
train_data, test_data = load_data()
X = train_data[:, :-1]
Y = train_data[:, -1]
Y = Y[:, np.newaxis]
print(X.shape)
print(Y.shape)
W1 = np.random.random((13, 13))*2-1
W2 = np.random.random((13, 13))*2-1
W3 = np.random.random((13, 1))*2-1
lr = 0.001
def sigmoid(x):
    return 1/(1+np.exp(-x))
def dsigmoid(x):
    return x*(1-x)
def update():
    global X, Y, W1, W2, W3, lr
    L3_delta = (Y - L3)*dsigmoid(L3)
    L2_delta = L3_delta.dot(W3.T)*dsigmoid(L2)
    L1_delta = L2_delta.dot(W2.T)*dsigmoid(L1)
    W3_C = lr * L2.T.dot(L3_delta)
    W2_C = lr * L1.T.dot(L2_delta)
    W1_C = lr * X.T.dot(L1_delta)
    W3 = W3 + W1_C
    W2 = W2 + W2_C
    W1 = W1 + W1_C

for i in range(10000):
      L1 = sigmoid(np.dot(X, W1)) # 隐层输出
      L2 = sigmoid(np.dot(L1, W2)) # 输出层输出
      L3 = sigmoid(np.dot(L2, W3)) # 输出层输出
      update()
      if (i+1)%1000==0:

            print("Error:", np.mean(np.abs(Y - L3)))

L3 = sigmoid(np.dot(L2, W3)) # 输出层输出

12月10日作业

1-2：完成下面两个问题，并将答案发布在帖子下面

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

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

作业1-2奖励：回复帖子且点赞top5，获得《深度学习导论与应用实践》教材+飞桨定制本

答：1，医院预约检查及预约挂号系统可以用监督学习框架来解决。

假设预约人次和诊疗时间成线性关系，输入为预约排队顺序，输出为诊疗时刻，优化目标为预约时间与实际诊查时间差在可以接受的范围，令医生等患者或患者等医生的时间均在合理范围。

2，AI工程师前景广阔，先说需求，人工智能方兴未艾，现实证明可行，是一条正确的路，市场会越来远大；市场越大，容量越大，但供给上量需要时间培养，不是朝夕之功。另外，AI咋兴，不乏羊群效应，当遇到困难时难免半途而废，选择就不轻言放弃，与如我一般的白丁共勉。

作业2-1：

（2）：

作业2-1：

（1）

12月12日作业

（1）答：

昵称：新壮-数据挖掘-北京

作业2-1 （1）基础题

计算过程：

12月12日作业

（1）

（2）

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：

张鹏-研发-上海

计算过程如下图：

计算结果：

2-2 挑战题

各层梯度公式推导：

两层网络的程序，一共修改了3处，具体看注释：

#双层网络房价预测模型，一共修改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.w1 = np.random.randn(num_of_weights, 13)
self.b1 = np.zeros((1, 13))
self.w2 = np.random.randn(13, 1)
self.b2 = 0.

#修改1：支持两层网络前向计算
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

#修改2：支持两层网络梯度值更新
def gradient(self, x, y):
z2 = self.forward(x)
N = x.shape[0]
self.gradient_w2 = 1. / N * np.dot(self.z1.T, z2 - y)
self.gradient_b2 = 1. / N * np.sum(z2 - y)
gradient_z1 = 1. / N * np.dot((z2 - y), self.w2.T)
self.gradient_w1 = np.dot(x.T, gradient_z1)
self.gradient_b1 = np.sum(gradient_z1, axis=0)
self.gradient_b1 = self.gradient_b1[np.newaxis, :]

#修改3：更新两层网络参数
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=100, eta=0.1)

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

作业1-1

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

1, 说一个和专业相关的吧，通信中的无线信道建模，据我了解的，比如说大尺度衰落模型，假设通信中接收信号的平均功率值（dB）与收发点之间的距离以及频点存在线性关系，这个可以根据Ferris公式推导出来自由空间中损耗，然而往往由于具体环境的不同，距离与频点前的系数就很受影响，所以为了在一个环境中实际得到具体信道模型，就需要经过测量一些参数（简单的来讲比如说收发端的距离，通信的频点，以及接收机的接收功率值），测量得到的大量数据通过训练可以根据距离以及频点得到一个估计的接收功率值，然后与实测的接收功率进行比对，优化目标就是使得均方误差最小，这个和那个房价预测差不多。如果有做过今年的研究生数学建模的同学，应该对A题有些印象，那个给的数据集的特征更多，可以说是我上述的一个加强版（更复杂点）。

2，对AI的行业了解的不是很多，第一次听说应该是AlphaGo吧，但如果说发展前景的话，感觉还是蛮有前途和钱图的（哈哈），首先呢，5G移动通信时代的到来势必会带来更大的数据业务，AI应该可以说是数据驱动吧；而且现在好多公司都想在该方面有一席之地或者更进一步，竞争是蛮激烈的，所以势必会有大量的需求。从经济的角度来讲，比如说一些产品的推荐，还有股票预测，银行相关的等等，这些会带来更大的资金流动以及直接与间接消费，有钱的地方就有热点。（个人看法，不对的地方请指正，可以多多交流）

作业1-1:

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

例如，身高与体重问题。假设：体重y,身高x，两者是线性关系y=k*x； 参数：为k，优化目标：是找出能拟合所有观测样本的最优k。

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

此图说明一切问题，以深度学习为基础的AI技术在各行业广泛应用，产生巨大经济价值

作业1-2：

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

例如，身高与体重问题。假设：体重y,身高x，两者是线性关系y=k*x； 参数：为k，优化目标：是找出能拟合所有观测样本的最优k。

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

此图说明一切问题，以深度学习为基础的AI技术在各行业广泛应用，产生巨大经济价值

作业1-2

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

1, 说一个和专业相关的吧，通信中的无线信道建模，据我了解的，比如说大尺度衰落模型，假设通信中接收信号的平均功率值（dB）与收发点之间的距离以及频点存在线性关系，这个可以根据Ferris公式推导出来自由空间中损耗，然而往往由于具体环境的不同，距离与频点的系数就很受影响，所以为了在一个环境中实际得到具体信道模型，就需要经过测量一些参数（简单的来讲比如说收发端的距离，通信的频点，以及收发端间的路径损耗），测量得到的大量数据通过训练可以根据距离以及频点得到一个估计的路径损耗，然后与实测的路径损耗进行比对，优化目标就是使得均方误差最小，这个和那个房价预测差不多。如果有做过今年的研究生数学建模的同学，应该对A题有些印象，那个给的数据集的特征更多，可以说是我上述的一个加强版（更复杂点）。

2，对AI的行业了解的不是很多，第一次听说应该是AlphaGo吧，但如果说发展前景的话，感觉还是蛮有前途和钱图的（哈哈），首先呢，5G移动通信时代的到来势必会带来更大的数据业务，AI应该可以说是数据驱动吧；而且现在好多公司都想在该方面有一席之地或者更进一步，竞争是蛮激烈的，所以势必会有大量的需求。从经济的角度来讲，比如说一些产品的推荐，还有股票预测，银行相关的等等，这些会带来更大的资金流动以及直接与间接消费，有钱的地方就有热点。

挑战题2

12-12 作业1

（1）

（2）

import numpy as np
from matplotlib import pyplot as plt
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):
# 随机产生w的初始值
# 为了保持程序每次运行结果的一致性，此处设置固定的随机数种子
#np.random.seed(0)
self.w1 = np.random.randn(num_of_weights, 1)
self.b1 = np.zeros((1,13))
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]
self.gradient_w2 = 1. / N * np.dot(self.z1.T, (z - y))
self.gradient_b2 = 1. / N * np.sum(z - y)
gradient_z1 = 1. / N * np.dot((z - y), self.w2.T)
self.gradient_w1 = np.dot(x.T, gradient_z1)
self.gradient_b1 = np.sum(gradient_z1, 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=100, eta=0.1)

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