一、数据处理

1.1 数据集介绍

本试验运用波士顿房价猜测数据集，共506条样本数据，每条样本包含了13种可能影响房价的要素和该类房子价格的中位数，各字段含义如下表所示：

字段名	类型	含义
CRIM	float	该镇的人均犯罪率
ZN	float	占地面积超过25,000平方呎的住所用地份额
INDUS	float	非零售商业用地份额
CHAS	int	是否附近 Charles River 1=附近；0=不附近
NOX	float	一氧化氮浓度
RM	float	每栋房子的平均客房数
AGE	float	1940年之前建成的自用单位份额
DIS	float	到波士顿5个就业中心的加权间隔
RAD	int	到径向公路的可达性指数
TAX	int	全值财产税率
PTRATIO	float	学生与教师的份额
B	float	1000(BK-0.63)^2，其间BK是城镇中黑人的份额
LSTAT	float	低收入人群占比
MEDV	float	同类房子价格的中位数

数据集下载地址：archive.ics.uci.edu/ml/machine-…

1.2 数据导入

（1）波士顿房价猜测数据集存储在文本文件中的数据格式为下图所示：

其间的X便是数据集介绍中的CRIM-LSTAT部分，而Y便是MEDV，即同类房子价格的中位数，也便是咱们后边要猜测的值。

（2）运用Numpy从文件导入数据np.fromfile

# 导入需求用到的package
import numpy as np
import json
# 读入练习数据
datafile = 'housing.data'
data = np.fromfile(datafile, sep=' ')

导入成果：

注释： np.tofile和np.fromfile能够完结数组写到磁盘文件中

print(data.shape)
# 输出(7084,)

咱们能够发现，咱们进行上述代码操作今后，将文件中的数据集生成了一个一维的数组，经过打印data.shape能够发现这个一维数组的长度为7084。细心的朋友不难发现，7084不便是506 x 14今后的成果吗~

没错，在这时分咱们就需求从头将data数据从头处理一下，用reshape()办法将其处理为(506, 14)的二维数组。

# 每条数据包含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])
print(data.shape)
# 输出(506, 14)
# 查看数据
X = data[0]
print(X.shape)
print(X)
# 输出
#(14,)
# [6.320e-03 1.800e+01 2.310e+00 0.000e+00 5.380e-01 6.575e+00 6.520e+01
# 4.090e+00 1.000e+00 2.960e+02 1.530e+01 3.969e+02 4.980e+00 2.400e+01]

由此能够看出每条数据是一个长度为14的一维数组，前13项是影响房价的要素，最终一项是房价。

1.3 数据集区分

在机器学习和深度学习进程中，往往要将数据集区分为练习集和测验集两部分，练习集用来进行练习，一般会取数据集的80%-90%，而测验集用来对练习好的模型功能进行评价，一般只取少量数据集，大约为10%左右。

ratio = 0.8
offset = int(data.shape[0] * ratio)
train_data = data[:offset]
test_data = data[offset:]
print(train_data.shape)
print(test_data.shape)
# 输出:
# (404, 14)
# (102, 14)

波士顿房价猜测数据会集原有数据集为506行，经过区分今后，练习集为本来的80%，即404，测验集为本来的20%，即102。

1.4 归一化处理

对特征取值范围进行归一化，有两个优点：

特征练习更高效
特征前的权重巨细可代表该变量对猜测成果的奉献度

留意：猜测时，样本数据相同也需求归一化，以练习样本的均值和极值核算

# 核算train数据集的最大值、最小值和平均值
maxinums, mininums, avgs = data_slice.max(axis=0), data_slice.min(axis=0), data_slice.sum(axis=0) / data_slice.shape[0]
# 对数据进行归一化处理
for i in range(feature_num):
    # print(maxinums[i], mininums[i], avgs[i])
    data[:, i] = (data[:, i] - avgs[i]) / (maxinums[i] - mininums[i])

1.5 将完好代码封装成load_data函数

def load_data():
    # 从文件导入数据
    datafile = 'housing.data'
    data = np.fromfile(datafile, sep=' ')
    print(data.shape)
    # 每条数据包含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])
    print(data.shape)
    X = data[0]
    print(X.shape)
    print(X)
    # 将原数据集拆分红练习集和测验集
    # 这里运用80%的数据做练习，20%的数据做测验
    # 测验集和练习集有必要是没有交集的
    ratio = 0.8
    offset = int(data.shape[0] * ratio)
    data_slice = data[:offset]
    # 核算train数据集的最大值、最小值和平均值
    maxinums, mininums, avgs = data_slice.max(axis=0), data_slice.min(axis=0), data_slice.sum(axis=0) / data_slice.shape[0]
    # 对数据进行归一化处理
    for i in range(feature_num):
        # print(maxinums[i], mininums[i], avgs[i])
        data[:, i] = (data[:, i] - avgs[i]) / (maxinums[i] - mininums[i])
    # 练习集和测验集的区分份额
    # ratio = 0.8
    train_data = data[:offset]
    test_data = data[offset:]
    return train_data, test_data

1.6 获取数据

# 获取数据
train_data, test_data = load_data()
print(train_data.shape)
x = train_data[:, :-1]
y = train_data[:, -1:]
print(x[0])
print(y[0])
#[-0.02146321  0.03767327 -0.28552309 -0.08663366  0.01289726  0.04634817
#  0.00795597 -0.00765794 -0.25172191 -0.11881188 -0.29002528  0.0519112
# -0.17590923]
#[-0.00390539]

二、规划模型

波士顿房价猜测事例是一个非常典型的线性回归问题。

2.1 前向核算

输入x一共有13个变量，y只有1个变量，所以权重w的shape是[13, 1]

w能够恣意赋初值如下

w = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, -0.1, -0.2, -0.3, -0.4, 0.0]
w = np.array(w).reshape([13, 1])

取出第1条样本数据，调查它与w相乘之后的成果

x1 = X[0]
t = np.dot(x1, w)
print(t)
# 输出：[0.03395597]

另外还需求初始化权重b，这里咱们给它赋值-0.2调查输出

b = -0.2
z = t + b
print(z)
# 输出 [-0.16604403]

2.2 以类的方法完结网络成果（前向核算）

运用时能够生成多个模型示例
类成员变量有w和b，在类初始化函数时初始化变量（w随机初始化，b = 0）
函数成员forward 完结从输入特征x到输出z的核算进程（即前向核算）

class NetWork(object):
    def __init__(self, num_of_weights):
        # 随机发生w的初始值
        # 为了坚持程序每次运转成果的一致性，此处设置了固定的随机数种子
        np.random.seed(0)
        self.w = np.random.randn(num_of_weights, 1)
        self.b = 0
    def forward(self, x):
        z = np.dot(x, self.w) + self.b
        return z

随机选取一个样本测验下效果

net = NetWork(13)
x1 = x[0]
y1 = y[0]
z = net.forward(x1)
print(z)
# 输出 [-0.63182506]

此刻咱们能够看出，现阶段搭建的模型只有一个花架子，并不具备猜测的能力，所以还需改进。

三、模型的丢失与优化

3.1 模型好坏的衡量指标——丢失函数（loss function）

在回归问题中均方差错是一种比较常见的方式，分类问题中通常会采用穿插熵丢失函数，后续有时机再给大家解说，咱们这篇文章主要解说均方差错。

3.2 练习配置—同时核算多个样本的丢失函数

在练习进程中，咱们要核算一切样本的丢失，而不是单个样本的丢失。

在此进程中咱们用到了Numpy的播送机制，便捷的完结多样本的核算 播送功能：像运用单一变量相同操作数组。

class NetWork(object):
    def __init__(self, num_of_weights):
        # 随机发生w的初始值
        # 为了坚持程序每次运转成果的一致性，此处设置了固定的随机数种子
        np.random.seed(0)
        self.w = np.random.randn(num_of_weights, 1)
        self.b = 0
    def forward(self, x):
        z = np.dot(x, self.w) + self.b
        return z
    def loss(self, z, y):
        error = z - y
        cost = error * error
        cost = np.mean(cost)
        return cost
net = NetWork(13)
x1 = x[0:3]
y1 = y[0:3]
z = net.forward(x1)
print('predict', z)
loss = net.loss(z, y1)
print('loss', loss)
# 输出 
# predict [[-0.63182506]
# [-0.55793096]
# [-1.00062009]]
# loss 0.7229825055441156

方案1：咱们在高中的时分就学习过，当一条曲线处于极值点的时分，斜率为0，即导数为0。那么咱们就能够依据上图中的导数方程来求解出参数w和b的值，以此来达到丢失函数极小值的目的。可是由于并不是一切的函数都是像均方差错这样可逆的，在咱们进行机器学习或许深度学习的进程中，遇见最多的便是不行逆函数，不行逆函数简单举个比如便是有一个y=x的方程，咱们能够依据y求导解出x，可是却不能依据x求导解出y。也便是说不能反过来求解，这便是不行逆函数。方案2：

在梯度下降法中，依据上图咱们能够了解为什么咱们运用均方差错而不是绝对差错，咱们能够看到，绝对值差错画出来的图画没有斜度，是不行微的，而均方差错画出的Loss函数图画能够看出是可微的，这姿态就能够让咱们在求解进程中更加的便利。

沿着梯度的反方向能够了解为沿着切线方向下降速度最快的方向，一般切线方向都是向上的，而反方向便是向下的方向。

四、梯度下降代码完结

4.1 练习进程—核算梯度的公式推导

咱们在进行梯度公式的推导之前，引入了1/2的因子，这样做的目的只是是为了咱们的推导进程更加的简练，没有其他目的，而且这样做并不影响咱们全体的推导进程。

4.1.1 练习进程—核算梯度的公式推导（一个样本）

4.1.2 练习进程—依据Numpy播送机制进行梯度核算（多个样本）

依据Numpy的播送机制，扩展参数的维度

4.1.3 练习进程—依据Numpy核算单个样本—>多个样本对梯度的奉献

相同，依据Nupy的播送机制，扩展样本的维度

4.1.4 练习进程—核算一切样本对梯度的奉献，代码十分简练

4.4.5 练习进程—一切样本对梯度的奉献取平均值

参数的更新方向要考虑一切样本的“定见”，总的梯度是一切样本对梯度奉献的平均值
运用Numpy里面的矩阵操作来完结此进程：

由于后续每走一小步都要进行维度的相加，所以（13，）要加上1维，变成（13，1），使得到梯度的维度和参数的维度一致，可是加上的1维相当所以虚的，由于13 x 1与13是相同的数字。

4.2 前向核算和后向传达的完好代码

全流程的步骤 1.前向核算 2.拿到1（前向核算的成果），才干核算丢失 3.拿到1和2，才干核算梯度 4.依据3，更新参数值

留意：其间第4步是反复循环进行的。

class NetWork(object):
    def __init__(self, num_of_weights):
        # 随机发生w的初始值
        # 为了坚持程序每次运转成果的一致性，此处设置了固定的随机数种子
        np.random.seed(0)
        self.w = np.random.randn(num_of_weights, 1)
        self.b = 0
    def forward(self, x):
        z = np.dot(x, self.w) + self.b
        return z
    def loss(self, z, y):
        error = z - y
        cost = error * error
        cost = np.mean(cost)
        return cost
    def gradient(self, x, y):
        z = self.forward(x)
        gradient_w = (z - y) * x
        gradient_w = np.mean(gradient_w, axis=0)  # axis=0表示把每一行做相加然后再除以总的行数
        gradient_w = gradient_w[:, np.newaxis]
        gradient_b = (z - y)
        gradient_b = np.mean(gradient_b)
        # 此处b是一个数值，所以能够直接用np.mean得到一个标量（scalar）
        return gradient_w, gradient_b
    def update(self, gradient_w, gradient_b, eta=0.01):    # eta代表学习率，是操控每次参数值变化的巨细，即移动步长，又称为学习率
        self.w = self.w - eta * gradient_w                 # 相减: 参数向梯度的反方向移动
        self.b = self.b - eta * gradient_b
    def train(self, x, y, iterations=1000, 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)		# 更新参数
            losses.append(L)
            if (i + 1) % 10 == 0:
                print('iter {}, loss {}'.format(i, L))
        return losses

五、完好代码

import numpy as np
from matplotlib import pyplot as plt
def load_data():
    # 从文件导入数据
    datafile = 'housing.data'
    data = np.fromfile(datafile, sep=' ')
    print(data.shape)
    # 每条数据包含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])
    print(data.shape)
    # 将原数据集拆分红练习集和测验集
    # 这里运用80%的数据做练习，20%的数据做测验
    # 测验集和练习集有必要是没有交集的
    ratio = 0.8
    offset = int(data.shape[0] * ratio)
    data_slice = data[:offset]
    # 核算train数据集的最大值、最小值和平均值
    maxinums, mininums, avgs = data_slice.max(axis=0), data_slice.min(axis=0), data_slice.sum(axis=0) / data_slice.shape[0]
    # 对数据进行归一化处理
    for i in range(feature_num):
        # print(maxinums[i], mininums[i], avgs[i])
        data[:, i] = (data[:, i] - avgs[i]) / (maxinums[i] - mininums[i])
    # 练习集和测验集的区分份额
    # ratio = 0.8
    train_data = data[:offset]
    test_data = data[offset:]
    return train_data, test_data
class NetWork(object):
    def __init__(self, num_of_weights):
        # 随机发生w的初始值
        # 为了坚持程序每次运转成果的一致性，此处设置了固定的随机数种子
        np.random.seed(0)
        self.w = np.random.randn(num_of_weights, 1)
        self.b = 0
    def forward(self, x):
        z = np.dot(x, self.w) + self.b
        return z
    def loss(self, z, y):
        error = z - y
        cost = error * error
        cost = np.mean(cost)
        return cost
    def gradient(self, x, y):
        z = self.forward(x)
        gradient_w = (z - y) * x
        gradient_w = np.mean(gradient_w, axis=0)  # axis=0表示把每一行做相加然后再除以总的行数
        gradient_w = gradient_w[:, np.newaxis]
        gradient_b = (z - y)
        gradient_b = np.mean(gradient_b)
        # 此处b是一个数值，所以能够直接用np.mean得到一个标量（scalar）
        return gradient_w, gradient_b
    def update(self, gradient_w, gradient_b, eta=0.01):    # eta代表学习率，是操控每次参数值变化的巨细，即移动步长，又称为学习率
        self.w = self.w - eta * gradient_w                 # 相减: 参数向梯度的反方向移动
        self.b = self.b - eta * gradient_b
    def train(self, x, y, iterations=1000, 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)
            losses.append(L)
            if (i + 1) % 10 == 0:
                print('iter {}, loss {}'.format(i, L))
        return losses
# 获取数据
train_data, test_data = load_data()
print(train_data.shape)
x = train_data[:, :-1]
y = train_data[:, -1:]
# 创建网络
net = NetWork(13)
num_iterations = 2000
# 启动练习
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()

练习成果：

波士顿房价预测——机器学习入门级案例

一、数据处理

1.1 数据集介绍

1.2 数据导入

1.3 数据集区分

1.4 归一化处理

1.5 将完好代码封装成load_data函数

1.6 获取数据

二、规划模型

2.1 前向核算

2.2 以类的方法完结网络成果（前向核算）

三、模型的丢失与优化

3.1 模型好坏的衡量指标——丢失函数（loss function）

3.2 练习配置—同时核算多个样本的丢失函数

四、梯度下降代码完结

4.1 练习进程—核算梯度的公式推导

4.1.1 练习进程—核算梯度的公式推导（一个样本）

4.1.2 练习进程—依据Numpy播送机制进行梯度核算（多个样本）

4.1.3 练习进程—依据Numpy核算单个样本—>多个样本对梯度的奉献

4.1.4 练习进程—核算一切样本对梯度的奉献，代码十分简练

4.4.5 练习进程—一切样本对梯度的奉献取平均值

4.2 前向核算和后向传达的完好代码

五、完好代码

作者信息

波士顿房价预测——机器学习入门级案例

一、数据处理

1.1 数据集介绍

1.2 数据导入

1.3 数据集区分

1.4 归一化处理

1.5 将完好代码封装成load_data函数

1.6 获取数据

二、规划模型

2.1 前向核算

2.2 以类的方法完结网络成果（前向核算）

三、模型的丢失与优化

3.1 模型好坏的衡量指标——丢失函数（loss function）

3.2 练习配置—同时核算多个样本的丢失函数

四、梯度下降代码完结

4.1 练习进程—核算梯度的公式推导

4.1.1 练习进程—核算梯度的公式推导（一个样本）

4.1.2 练习进程—依据Numpy播送机制进行梯度核算（多个样本）

4.1.3 练习进程—依据Numpy核算单个样本—>多个样本对梯度的奉献

4.1.4 练习进程—核算一切样本对梯度的奉献，代码十分简练

4.4.5 练习进程—一切样本对梯度的奉献取平均值

4.2 前向核算和后向传达的完好代码

五、完好代码

相关文章

Copilot X都出来了，不会还有人没用过Copilot吧 | 人工智能周刊第12期

Android 10 电源管理分析之WakeLock （二）

使用 DeepSpeed 和 Accelerate 进行超快 BLOOM 模型推理

强推集成GPT-4的编辑器Cursor；面向ChatGPT编程18种方法；如何将AI绘画融合于工作流；ChatGPT SEO公式大揭秘 | ShowMeAI日报

作者信息