当前位置： 首页 > news >正文

pytorh学习笔记——波士顿房价预测

news 2026/3/26 14:49:07

 机器学习的“hello world”：波士顿房价预测

        波士顿房价预测的背景不用提了，简单了解一下数据集的结构。 
        波士顿房价的数据集，共有506组数据，每组数据共14项，前13项是影响房价的各种因素，比如：城镇人均犯罪率、一氧化氮浓度之类的，最后一项是基于前面的因素的房价。

一、逻辑框架 

 二、程序框架

import torch  # 导入pytorch# data   解析数据# net   # 搭建网络# loss   # 计算损失# optimizer   # 优化器# train   # 训练# test   # 测试

1、训练的初步的脚本

新建demo_net.py，输入代码：

import torch# data   解析数据
import numpy as np
import reff = open('housing.data', 'r').readlines()  # 读取数据
data = []    # 存储数据
for item in ff:out = re.sub(r'\s{2,}', ' ', item).strip()   # 去除多余空格（将多个空格替换为一个空格）data.append(out.split(' '))    # 按照空格分割数据并添加到data中data = np.array(data, dtype=np.float32)  # 转换为numpy数组
# print(data.shape)  # 打印数据形状  (506, 14)
Y = data[:, -1]  # 获取标签(所有行的最后一列)
X = data[:, :-1]  # 获取特征(所有行的除最后一列的所有列)Y_train = Y[0:496, ...]  # 训练集标签
X_train = X[0:496, ...]  # 训练集特征
Y_test = Y[496:, ...]  # 测试集标签
X_test = X[496:, ...]  # 测试集特征# print(Y_train.shape)  # 打印训练集标签形状  (496,)
# print(X_train.shape)  # 打印训练集特征形状  (496, 13)
# print(Y_test.shape)  # 打印测试集标签形状   (10,)
# print(X_test.shape)  # 打印测试集特征形状   (10, 13)# net   # 搭建网络
class Net(torch.nn.Module):   # 定义网络def __init__(self, n_feature, n_output):   # n_feature:输入特征数，n_output:输出特征数super(Net, self).__init__()self.predict = torch.nn.Linear(n_feature, n_output)   # 定义网络结构(线性回归）def forward(self, x):   # 前向传播y = self.predict(x)return ynet = Net(13, 1)   # 实例化网络# loss   # 计算损失
loss_func = torch.nn.MSELoss()   # 定义损失函数(均方误差）# optimizer   # 优化器
optimizer = torch.optim.Adam(net.parameters(), lr=0.0001)   # 定义优化器# train   # 训练
x_data = torch.tensor(X_train, dtype=torch.float32)   # 将训练集特征转换为tensor
y_data = torch.tensor(Y_train, dtype=torch.float32)   # 将训练集标签转换为tensor
for i in range(10000):   # 训练10000次pred = net.forward(x_data)   # 前向传播，返回的是一个二维tensor# print(pred.shape)   # 打印预测结果形状  (496, 1)pred = torch.squeeze(pred)   # 由于返回的是二维的tensor，所以需要去掉维度为1的维度loss = loss_func(pred, y_data)  # 计算损失optimizer.zero_grad()   # 清空上一次的梯度loss.backward()   # 反向传播optimizer.step()   # 优化器更新参数if (i+1) % 1000 == 0:   # 每1000次打印一次损失print('第{}次训练，损失为{}'.format(i+1, loss))print('预测结果为{}'.format(pred[:10]))print('真实结果为{}'.format(y_data[:10]))# test   # 测试

 运行结果：

第1000次训练，损失为213.7091064453125
预测结果为tensor([30.3859, 35.9642, 30.5334, 27.4028, 29.8967, 30.7044, 31.1800, 38.9477,41.2886, 35.3080], grad_fn=<SliceBackward0>)
真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第2000次训练，损失为115.01570129394531
预测结果为tensor([25.6781, 28.8944, 24.1358, 20.5663, 22.7628, 23.5741, 26.7624, 33.8008,35.9616, 30.7862], grad_fn=<SliceBackward0>)
真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第3000次训练，损失为92.31402587890625
预测结果为tensor([24.9008, 25.9834, 22.5986, 19.7416, 21.3243, 21.9060, 25.3798, 30.4637,31.5297, 28.2170], grad_fn=<SliceBackward0>)
真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第4000次训练，损失为78.46049499511719
预测结果为tensor([24.7822, 24.7402, 22.6722, 20.6557, 21.6591, 21.9934, 24.7024, 27.8985,27.8058, 26.3184], grad_fn=<SliceBackward0>)
真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第5000次训练，损失为69.00062561035156
预测结果为tensor([24.8879, 24.1986, 23.2193, 21.9481, 22.4841, 22.6186, 24.2389, 25.9268,24.7516, 24.8738], grad_fn=<SliceBackward0>)
真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第6000次训练，损失为62.37424850463867
预测结果为tensor([25.2287, 24.1047, 23.8811, 23.1481, 23.3747, 23.3950, 23.9017, 24.6387,22.4893, 23.9274], grad_fn=<SliceBackward0>)
真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第7000次训练，损失为57.1735954284668
预测结果为tensor([25.7705, 24.3499, 24.5864, 24.1829, 24.2396, 24.2240, 23.6420, 23.9154,20.8723, 23.3721], grad_fn=<SliceBackward0>)
真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第8000次训练，损失为52.881893157958984
预测结果为tensor([26.3800, 24.6829, 25.2719, 25.0930, 25.0307, 25.0057, 23.3551, 23.3264,19.4090, 22.8640], grad_fn=<SliceBackward0>)
真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第9000次训练，损失为49.33217239379883
预测结果为tensor([26.9553, 24.9474, 25.9011, 25.8923, 25.7059, 25.6638, 22.9824, 22.6079,17.8117, 22.2006], grad_fn=<SliceBackward0>)
真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第10000次训练，损失为46.42286682128906
预测结果为tensor([27.4543, 25.1425, 26.4893, 26.5836, 26.2601, 26.1888, 22.5538, 21.7727,16.1070, 21.4219], grad_fn=<SliceBackward0>)
真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])

看得出，当前的预测结果还是有很大的偏差的。

2、改进后的训练脚本

        .提高学习率，将学习率设为0.01

第10000次训练，损失为22.985254287719727
预测结果为tensor([29.2464, 24.2876, 30.5644, 28.9724, 28.4927, 25.0255, 21.5255, 18.3571,10.0867, 17.6953], grad_fn=<SliceBackward0>)
真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])

提高学习率之后，收敛更快，所以损失从46.4降到了22.9。

        .增加训练次数，训练100000次

第100000次训练，损失为21.93065071105957
预测结果为tensor([30.0387, 25.0656, 30.6645, 28.7074, 28.0154, 25.3406, 22.7764, 19.2288,11.0369, 18.6134], grad_fn=<SliceBackward0>)
真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])

增加训练次数后，损失略有下降，但不明显。

        .加入隐藏层

将网络的定义更换为下面的代码：

# net   # 搭建网络
class Net(torch.nn.Module):   # 定义网络def __init__(self, n_feature, n_output):   # n_feature:输入特征数，n_output:输出特征数super(Net, self).__init__()self.hidden = torch.nn.Linear(n_feature, 100)  # 定义隐藏层self.predict = torch.nn.Linear(100, n_output)   # 定义网络结构(线性回归）def forward(self, x):   # 前向传播y = self.hidden(x)   # 隐藏层y = torch.relu(y)   # 激活函数y = self.predict(y)return y

 运行结果：

第1000次训练，损失为16.16332244873047
预测结果为tensor([31.5807, 24.7012, 31.1625, 33.0276, 29.9564, 28.7967, 21.1699, 17.8390,11.0052, 17.8434], grad_fn=<SliceBackward0>)
真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第2000次训练，损失为10.760713577270508
预测结果为tensor([31.2304, 21.0812, 30.4874, 34.0178, 30.2638, 26.8140, 21.4654, 19.2940,15.2969, 18.9148], grad_fn=<SliceBackward0>)
真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第3000次训练，损失为9.041060447692871
预测结果为tensor([30.0590, 22.6623, 31.4998, 34.3279, 34.0962, 28.8110, 22.4006, 20.0406,17.4557, 19.8644], grad_fn=<SliceBackward0>)
真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第4000次训练，损失为7.654926776885986
预测结果为tensor([28.6500, 22.9828, 31.4478, 34.5795, 35.0444, 28.6649, 22.2122, 20.1728,17.4889, 19.9103], grad_fn=<SliceBackward0>)
真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第5000次训练，损失为7.204400539398193
预测结果为tensor([25.6355, 21.1540, 29.2047, 32.6562, 33.3360, 26.2489, 20.5876, 18.6758,15.7114, 18.5272], grad_fn=<SliceBackward0>)
真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第6000次训练，损失为4.584250450134277
预测结果为tensor([25.8020, 21.5723, 30.2412, 33.8467, 34.3686, 27.0365, 21.3067, 19.1034,16.5482, 19.0247], grad_fn=<SliceBackward0>)
真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第7000次训练，损失为3.7115399837493896
预测结果为tensor([26.3502, 21.7220, 30.8541, 34.7135, 35.1162, 27.7273, 22.0456, 19.7786,17.4401, 19.6452], grad_fn=<SliceBackward0>)
真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第8000次训练，损失为4.195467472076416
预测结果为tensor([25.8955, 21.2075, 30.6258, 34.2735, 34.5896, 27.4262, 21.6917, 19.4653,17.4221, 19.2694], grad_fn=<SliceBackward0>)
真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第9000次训练，损失为3.0317327976226807
预测结果为tensor([26.5321, 21.7933, 32.1591, 34.9432, 34.8340, 28.1285, 22.0055, 20.0637,18.4400, 19.3234], grad_fn=<SliceBackward0>)
真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第10000次训练，损失为2.727705478668213
预测结果为tensor([26.0240, 21.3191, 32.9476, 35.2049, 34.8349, 27.9297, 22.2083, 20.0651,18.3588, 18.8366], grad_fn=<SliceBackward0>)
真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])

看得出，10000次训练后，损失已经降到了2.7，比起之前已经大有提高。

3、测试

加入测试代码后：

import torch# data   解析数据
import numpy as np
import reff = open('housing.data', 'r').readlines()  # 读取数据
data = []    # 存储数据
for item in ff:out = re.sub(r'\s{2,}', ' ', item).strip()   # 去除多余空格（将多个空格替换为一个空格）data.append(out.split(' '))    # 按照空格分割数据并添加到data中data = np.array(data, dtype=np.float32)  # 转换为numpy数组
# print(data.shape)  # 打印数据形状  (506, 14)
Y = data[:, -1]  # 获取标签(所有行的最后一列)
X = data[:, :-1]  # 获取特征(所有行的除最后一列的所有列)Y_train = Y[0:496, ...]  # 训练集标签
X_train = X[0:496, ...]  # 训练集特征
Y_test = Y[496:, ...]  # 测试集标签
X_test = X[496:, ...]  # 测试集特征# print(Y_train.shape)  # 打印训练集标签形状  (496,)
# print(X_train.shape)  # 打印训练集特征形状  (496, 13)
# print(Y_test.shape)  # 打印测试集标签形状   (10,)
# print(X_test.shape)  # 打印测试集特征形状   (10, 13)# net   # 搭建网络
class Net(torch.nn.Module):   # 定义网络def __init__(self, n_feature, n_output):   # n_feature:输入特征数，n_output:输出特征数super(Net, self).__init__()self.hidden = torch.nn.Linear(n_feature, 100)  # 定义隐藏层self.predict = torch.nn.Linear(100, n_output)   # 定义网络结构(线性回归）def forward(self, x):   # 前向传播y = self.hidden(x)   # 隐藏层y = torch.relu(y)   # 激活函数y = self.predict(y)return ynet = Net(13, 1)   # 实例化网络# loss   # 计算损失
loss_func = torch.nn.MSELoss()   # 定义损失函数(均方误差）# optimizer   # 优化器
optimizer = torch.optim.Adam(net.parameters(), lr=0.01)   # 定义优化器# train   # 训练
train_x_data = torch.tensor(X_train, dtype=torch.float32)   # 将训练集特征转换为tensor
train_y_data = torch.tensor(Y_train, dtype=torch.float32)   # 将训练集标签转换为tensor
test_x_data = torch.tensor(X_test, dtype=torch.float32)   # 将测试集特征转换为tensor
test_y_data = torch.tensor(Y_test, dtype=torch.float32)   # 将测试集标签转换为tensor
for i in range(10000):   # 训练10000次pred_train = net.forward(train_x_data)   # 前向传播，返回的是一个二维tensor# print(pred.shape)   # 打印预测结果形状  (496, 1)pred_train = torch.squeeze(pred_train)   # 由于返回的是二维的tensor，所以需要去掉维度为1的维度loss_train = loss_func(pred_train, train_y_data)  # 计算损失optimizer.zero_grad()   # 清空上一次的梯度loss_train.backward()   # 反向传播optimizer.step()   # 优化器更新参数# test   # 测试pred_test = net.forward(test_x_data)pred_test = torch.squeeze(pred_test)loss_test = loss_func(pred_test, test_y_data)  # 计算损失if (i+1) % 1000 == 0:   # 每1000次打印一次损失print('第{}次训练，训练损失为{}'.format(i + 1, loss_train))print('训练预测结果为{}'.format(pred_train[:10]))print('训练真实结果为{}'.format(train_y_data[:10]))print('第{}次训练，测试损失为{}'.format(i + 1, loss_test))print('测试预测结果为{}'.format(pred_test[:10]))print('测试真实结果为{}'.format(test_y_data[:10]))

 运行结果：

C:\Users\DY\.conda\envs\torch\python.exe E:\AI_tset\boston\main.py 
第1000次训练，训练损失为13.062897682189941
训练预测结果为tensor([32.4538, 22.4545, 31.6084, 34.6321, 30.7499, 28.7717, 21.2537, 18.4388,14.3816, 17.8076], grad_fn=<SliceBackward0>)
训练真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第1000次训练，测试损失为15.603384017944336
测试预测结果为tensor([17.2584, 20.4116, 21.6079, 19.7471, 20.3963, 21.4410, 21.3918, 28.3847,25.5809, 21.5427], grad_fn=<SliceBackward0>)
测试真实结果为tensor([19.7000, 18.3000, 21.2000, 17.5000, 16.8000, 22.4000, 20.6000, 23.9000,22.0000, 11.9000])
第2000次训练，训练损失为9.312514305114746
训练预测结果为tensor([28.3546, 20.2573, 28.6708, 33.5919, 31.0789, 25.5264, 20.3330, 18.5948,15.6572, 17.6856], grad_fn=<SliceBackward0>)
训练真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第2000次训练，测试损失为14.083860397338867
测试预测结果为tensor([18.4503, 20.9926, 22.3660, 20.1845, 21.4613, 22.1625, 20.6208, 28.3789,25.4795, 20.2372], grad_fn=<SliceBackward0>)
测试真实结果为tensor([19.7000, 18.3000, 21.2000, 17.5000, 16.8000, 22.4000, 20.6000, 23.9000,22.0000, 11.9000])
第3000次训练，训练损失为6.208388328552246
训练预测结果为tensor([28.0445, 21.0570, 29.5777, 34.5575, 34.3055, 28.3384, 20.9634, 19.6007,16.1345, 18.6369], grad_fn=<SliceBackward0>)
训练真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第3000次训练，测试损失为6.905886650085449
测试预测结果为tensor([16.9234, 19.6245, 21.3344, 18.5896, 20.3094, 21.4729, 19.0355, 24.3601,22.2127, 18.4200], grad_fn=<SliceBackward0>)
测试真实结果为tensor([19.7000, 18.3000, 21.2000, 17.5000, 16.8000, 22.4000, 20.6000, 23.9000,22.0000, 11.9000])
第4000次训练，训练损失为5.641458511352539
训练预测结果为tensor([25.9988, 21.0524, 29.1003, 33.8196, 34.5036, 27.8455, 20.7901, 19.6908,15.6711, 18.6173], grad_fn=<SliceBackward0>)
训练真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第4000次训练，测试损失为8.056257247924805
测试预测结果为tensor([17.5898, 20.1642, 21.8730, 19.0862, 21.0310, 22.3734, 19.6710, 24.7076,22.8086, 18.9423], grad_fn=<SliceBackward0>)
测试真实结果为tensor([19.7000, 18.3000, 21.2000, 17.5000, 16.8000, 22.4000, 20.6000, 23.9000,22.0000, 11.9000])
第5000次训练，训练损失为5.656107425689697
训练预测结果为tensor([25.2531, 20.6933, 28.9231, 32.7898, 34.1414, 27.3489, 20.4208, 19.7374,15.6711, 18.3137], grad_fn=<SliceBackward0>)
训练真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第5000次训练，测试损失为10.021121978759766
测试预测结果为tensor([19.1231, 20.8267, 22.5154, 19.6338, 21.5662, 23.3536, 20.3911, 25.4182,23.7853, 19.5190], grad_fn=<SliceBackward0>)
测试真实结果为tensor([19.7000, 18.3000, 21.2000, 17.5000, 16.8000, 22.4000, 20.6000, 23.9000,22.0000, 11.9000])
第6000次训练，训练损失为4.3244428634643555
训练预测结果为tensor([26.9243, 21.3463, 30.2934, 34.4237, 35.6593, 29.0201, 21.4505, 20.5173,17.6037, 18.9231], grad_fn=<SliceBackward0>)
训练真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第6000次训练，测试损失为6.1388702392578125
测试预测结果为tensor([19.1049, 20.0117, 21.6194, 18.9644, 20.5173, 22.2967, 19.1247, 23.9584,22.5197, 18.1853], grad_fn=<SliceBackward0>)
测试真实结果为tensor([19.7000, 18.3000, 21.2000, 17.5000, 16.8000, 22.4000, 20.6000, 23.9000,22.0000, 11.9000])
第7000次训练，训练损失为4.283013343811035
训练预测结果为tensor([27.0127, 22.1808, 30.9352, 35.3205, 36.2137, 29.5154, 21.7429, 20.6820,18.5019, 19.3641], grad_fn=<SliceBackward0>)
训练真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第7000次训练，测试损失为4.814659118652344
测试预测结果为tensor([18.5595, 19.3107, 21.0298, 18.4600, 19.9520, 21.3664, 17.8218, 23.2565,21.3452, 16.9308], grad_fn=<SliceBackward0>)
测试真实结果为tensor([19.7000, 18.3000, 21.2000, 17.5000, 16.8000, 22.4000, 20.6000, 23.9000,22.0000, 11.9000])
第8000次训练，训练损失为4.039644718170166
训练预测结果为tensor([26.9686, 22.5262, 31.3496, 35.2846, 36.3410, 29.3871, 21.7442, 20.7460,18.5969, 19.5158], grad_fn=<SliceBackward0>)
训练真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第8000次训练，测试损失为4.698439598083496
测试预测结果为tensor([18.2167, 19.3340, 21.3022, 18.2839, 20.1922, 21.6993, 17.1337, 23.3157,21.3075, 16.1727], grad_fn=<SliceBackward0>)
测试真实结果为tensor([19.7000, 18.3000, 21.2000, 17.5000, 16.8000, 22.4000, 20.6000, 23.9000,22.0000, 11.9000])
第9000次训练，训练损失为4.54683256149292
训练预测结果为tensor([23.9196, 20.3218, 29.5554, 32.8275, 34.2579, 27.2489, 20.4540, 18.9822,17.2778, 18.3638], grad_fn=<SliceBackward0>)
训练真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第9000次训练，测试损失为8.086548805236816
测试预测结果为tensor([19.2664, 20.9391, 22.9442, 19.6506, 21.8333, 23.6144, 18.8776, 24.7309,22.6941, 17.8243], grad_fn=<SliceBackward0>)
测试真实结果为tensor([19.7000, 18.3000, 21.2000, 17.5000, 16.8000, 22.4000, 20.6000, 23.9000,22.0000, 11.9000])
第10000次训练，训练损失为3.7810146808624268
训练预测结果为tensor([23.9642, 20.4657, 29.9442, 32.6707, 34.3400, 27.2285, 20.6211, 19.3677,17.7232, 18.5607], grad_fn=<SliceBackward0>)
训练真实结果为tensor([24.0000, 21.6000, 34.7000, 33.4000, 36.2000, 28.7000, 22.9000, 27.1000,16.5000, 18.9000])
第10000次训练，测试损失为7.744905948638916
测试预测结果为tensor([19.1582, 20.7719, 22.6360, 19.5414, 21.7677, 23.4768, 19.0810, 24.2579,22.2269, 17.9408], grad_fn=<SliceBackward0>)
测试真实结果为tensor([19.7000, 18.3000, 21.2000, 17.5000, 16.8000, 22.4000, 20.6000, 23.9000,22.0000, 11.9000])进程已结束,退出代码0

4、保存和加载

#  第一种保存和加载方法
torch.save(net.state_dict(), 'net_dict.pkl')   # 保存模型参数
net.load_state_dict(torch.load('net_dict.pkl'))   # 加载模型参数#  第二种保存和加载方法
torch.save(net, 'net.pkl')   # 保存模型
torch.load('net.pkl')   # 加载模型

 加入保存代码后的完整代码：

import torch# data   解析数据
import numpy as np
import reff = open('housing.data', 'r').readlines()  # 读取数据
print(ff)
data = []    # 存储数据
for item in ff:out = re.sub(r'\s{2,}', ' ', item).strip()   # 去除多余空格（将多个空格替换为一个空格）data.append(out.split(' '))    # 按照空格分割数据并添加到data中data = np.array(data, dtype=np.float32)  # 转换为numpy数组
# print(data.shape)  # 打印数据形状  (506, 14)
Y = data[:, -1]  # 获取标签(所有行的最后一列)
X = data[:, 0:-1]  # 获取特征(所有行的除最后一列的所有列)Y_train = Y[0:496, ...]  # 训练集标签
X_train = X[0:496, ...]  # 训练集特征
Y_test = Y[496:, ...]  # 测试集标签
X_test = X[496:, ...]  # 测试集特征# print(Y_train.shape)  # 打印训练集标签形状  (496,)
# print(X_train.shape)  # 打印训练集特征形状  (496, 13)
# print(Y_test.shape)  # 打印测试集标签形状   (10,)
# print(X_test.shape)  # 打印测试集特征形状   (10, 13)# net   # 搭建网络
class Net(torch.nn.Module):   # 定义网络def __init__(self, n_feature, n_output):   # n_feature:输入特征数，n_output:输出特征数super(Net, self).__init__()self.hidden = torch.nn.Linear(n_feature, 100)  # 定义隐藏层self.predict = torch.nn.Linear(100, n_output)   # 定义网络结构(线性回归）def forward(self, x):   # 前向传播y = self.hidden(x)   # 隐藏层y = torch.relu(y)   # 激活函数y = self.predict(y)return ynet = Net(13, 1)   # 实例化网络# loss   # 计算损失
loss_func = torch.nn.MSELoss()   # 定义损失函数(均方误差）# optimizer   # 优化器
optimizer = torch.optim.Adam(net.parameters(), lr=0.01)   # 定义优化器# train   # 训练
train_x_data = torch.tensor(X_train, dtype=torch.float32)  # 将训练集特征转换为tensor
train_y_data = torch.tensor(Y_train, dtype=torch.float32)  # 将训练集标签转换为tensor
test_x_data = torch.tensor(X_test, dtype=torch.float32)  # 将测试集特征转换为tensor
test_y_data = torch.tensor(Y_test, dtype=torch.float32)  # 将测试集标签转换为tensor
for i in range(10000):   # 训练10000次pred_train = net.forward(train_x_data)   # 前向传播，返回的是一个二维tensor# print(pred.shape)   # 打印预测结果形状  (496, 1)pred_train = torch.squeeze(pred_train)   # 由于返回的是二维的tensor，所以需要去掉维度为1的维度loss_train = loss_func(pred_train, train_y_data)  # 计算损失optimizer.zero_grad()   # 清空上一次的梯度loss_train.backward()   # 反向传播optimizer.step()   # 优化器更新参数# test   # 测试pred_test = net.forward(test_x_data)pred_test = torch.squeeze(pred_test)loss_test = loss_func(pred_test, test_y_data)  # 计算损失if (i+1) % 1000 == 0:   # 每1000次打印一次损失print('第{}次训练，训练损失为{}'.format(i + 1, loss_train))print('训练预测结果为{}'.format(pred_train[:10]))print('训练真实结果为{}'.format(train_y_data[:10]))print('第{}次测试，测试损失为{}'.format(i + 1, loss_test))print('测试预测结果为{}'.format(pred_test[:10]))print('测试真实结果为{}'.format(test_y_data[:10]))# #  第一种保存和加载方法
# torch.save(net.state_dict(), 'net_dict.pkl')   # 保存模型参数
# net.load_state_dict(torch.load('net_dict.pkl'))   # 加载模型参数#  第二种保存和加载方法
torch.save(net, 'net.pkl')   # 保存模型
# torch.load('net.pkl')   # 加载模型
print('已保存')

5、推理

新建inference.py，输入：

import torch
# from demo_net import Net   # 使用这种方法会重复训练
# data   解析数据
import numpy as np
import reclass Net(torch.nn.Module):   # 定义网络   # 将之前定义的网络复制过来def __init__(self, n_feature, n_output):   # n_feature:输入特征数，n_output:输出特征数super(Net, self).__init__()self.hidden = torch.nn.Linear(n_feature, 100)  # 定义隐藏层self.predict = torch.nn.Linear(100, n_output)   # 定义网络结构(线性回归）def forward(self, x):   # 前向传播y = self.hidden(x)   # 隐藏层y = torch.relu(y)   # 激活函数y = self.predict(y)return yff = open('housing.data', 'r').readlines()  # 读取数据
data = []    # 存储数据
for item in ff:out = re.sub(r'\s{2,}', ' ', item).strip()   # 去除多余空格（将多个空格替换为一个空格）data.append(out.split(' '))    # 按照空格分割数据并添加到data中data = np.array(data).astype(np.float32)  # 转换为numpy数组
# print(data.shape)  # 打印数据形状  (506, 14)
Y = data[:, -1]  # 获取标签(所有行的最后一列)
X = data[:, :-1]  # 获取特征(所有行的除最后一列的所有列)Y_train = Y[0:496, ...]  # 训练集标签
X_train = X[0:496, ...]  # 训练集特征
Y_test = Y[496:, ...]  # 测试集标签
X_test = X[496:, ...]  # 测试集特征net = torch.load('net.pkl')
loss_func = torch.nn.MSELoss()   # 定义损失函数(均方误差）test_x_data = torch.tensor(X_test, dtype=torch.float32)   # 将测试集特征转换为tensor
test_y_data = torch.tensor(Y_test, dtype=torch.float32)   # 将测试集标签转换为tensor
pred_test = net.forward(test_x_data)
pred_test = torch.squeeze(pred_test)
loss_test = loss_func(pred_test, test_y_data)  # 计算损失print('测试集预测结果：', pred_test)
print('测试集实际结果:', Y_test)
print('测试集损失：', loss_test)   # 打印测试集损失

 运行后，直接得出了推理结果：

测试集预测结果： tensor([17.9976, 20.7273, 22.6870, 19.7387, 22.0204, 23.5350, 19.9008, 23.2567,22.4825, 18.6679], grad_fn=<SqueezeBackward0>)
测试集实际结果: [19.7 18.3 21.2 17.5 16.8 22.4 20.6 23.9 22.  11.9]
测试集损失： tensor(9.1494, grad_fn=<MseLossBackward0>)

存疑：在推理的脚本里使用torch.load()调用之前自定义并保存的网络，如使用from demo_net import Net的方法调用，运行推理脚本后，则会又执行一次训练过程。而将之前定义的网络直接复制到推理脚本则不会。

相关文章：

pytorh学习笔记——波士顿房价预测

机器学习的“hello world”&#xff1a;波士顿房价预测 波士顿房价预测的背景不用提了&#xff0c;简单了解一下数据集的结构。 波士顿房价的数据集&#xff0c;共有506组数据&#xff0c;每组数据共14项&#xff0c;前13项是影响房价的各种因素&#xff0c;比如&…...

编程日记 2024/10/12 9:42:13

让AI像人一样思考和使用工具，reAct机制详解

reAct机制详解 reAct是什么reAct的关键要素reAct的思维过程reAct的代码实现查看效果引入依赖&#xff0c;定义模型定义相关工具集合工具创建代理启动测试完整代码 思考 reAct是什么 reAct的核心思想是将**推理&#xff08;Reasoning&#xff09;和行动&#xff08;Acting&…...

编程日记 2024/10/12 9:41:11

Linux系列-常见的指令（二）

&#x1f308;个人主页&#xff1a; 羽晨同学 &#x1f4ab;个人格言:“成为自己未来的主人~” mv 剪切文件&#xff0c;目录 重命名 比如说&#xff0c;我们在最开始创建一个新的文件hello.txt 然后我们将这个文件改一个名字&#xff0c;改成world.txt 所以&#xff0c;…...

编程日记 2024/10/12 9:40:10

Leecode刷题之路第17天之电话号码的字母组合

题目出处 17-电话号码的字母组合-题目出处 题目描述 个人解法 思路&#xff1a; todo 代码示例&#xff1a;&#xff08;Java&#xff09; todo复杂度分析 todo 官方解法 17-电话号码的字母组合-官方解法 方法1&#xff1a;回溯 思路&#xff1a; 代码示例&#xff1a;&a…...

编程日记 2024/10/12 9:39:08

2023牛客暑期多校训练营3（题解）

今天下午也是小小的做了一下&#xff0c;OI&#xff0c;也是感觉手感火热啊&#xff0c;之前无意间看到的那个哥德巴赫定理今天就用到了&#xff0c;我以为根本用不到的&#xff0c;当时也只是感兴趣看了一眼&#xff0c;还是比较激动啊 话不多说&#xff0c;直接开始看题 Wo…...

编程日记 2024/10/12 9:37:06

Magnum IO

NVIDIA Magnum IO 文章目录 前言加速数据中心 IO 性能，随时随地助力 AINVIDIA Magnum IO 优化堆栈1. 存储 IO2. 网络 IO3. 网内计算4. IO 管理跨数据中心应用加速 IO1. 数据分析Magnum IO 库和数据分析工具2. 高性能计算Magnum IO 库和 HPC 应用3. 深度学习Magnum IO 库和深度…...

编程日记 2024/10/12 9:36:04

Flink job的提交流程

在Flink中&#xff0c;作业&#xff08;Job&#xff09;的提交流程是一个复杂的过程&#xff0c;涉及多个组件和模块&#xff0c;包括作业的编译、优化、序列化、任务分发、任务调度、资源分配等。Flink通过分布式架构来管理作业的生命周期&#xff0c;确保作业在不同节点上以高…...

编程日记 2024/10/12 9:35:01

git操作pull的时候出现冲突怎么解决

问&#xff1a; PS C:\Users\fury_123\Desktop\consumptionforecast> git branch * dev main PS C:\Users\fury_123\Desktop\consumptionforecast> git add . PS C:\Users\fury_123\Desktop\consumptionforecast> git commit -m 修改部分样式 [dev 74693e0] 修改部分样…...

编程日记 2024/10/12 9:32:57

Sentinel 1.80(CVE-2021-44139)

Sentinel 是面向分布式、多语言异构化服务架构的流量治理组件&#xff0c;主要以流量为切入点&#xff0c;从流量路由、流量控制、流量整形、熔断降级、系统自适应过载保护、热点流量防护等多个维度来帮助开发者保障微服务的稳定性 Report a Sentinel Security Vulnerability …...

编程日记 2024/10/12 9:25:46

黑马程序员C++提高编程学习笔记

黑马程序员C提高编程 提高阶段主要针对泛型编程和STL技术 文章目录 黑马程序员C提高编程一、模板1.1 函数模板1.1.1 函数模板基础知识 案例一&#xff1a; 数组排序1.2.1 普通函数与函数模板1.2.2 函数模板的局限性 1.2 类模板1.2.1 类模板的基础知识1.2.2 类模板与函数模板1.…...

编程日记 2024/10/12 9:24:45

力扣第1题：两数之和（图解版）

Golang版本 func twoSum(nums []int, target int) []int {m : make(map[int]int)for i : range nums {if _, ok : m[target - nums[i]]; ok {return []int{i, m[target - nums[i]]}} m[nums[i]] i}return nil }...

编程日记 2024/10/12 9:20:39

aws(学习笔记第三课) AWS CloudFormation

aws(学习笔记第三课) 使用AWS CloudFormation 学习内容&#xff1a; AWS CloudFormation的模板解析使用AWS CloudFormation启动ec2 server 1. AWS CloudFormation 的模版解析 CloudFormation模板结构 CloudFormation是AWS的配置管理工具&#xff0c;属于Infrastructure as Co…...

编程日记 2024/10/12 9:19:38

浅学React和JSX

往期推荐 一文搞懂大数据流式计算引擎Flink【万字详解&#xff0c;史上最全】-CSDN博客 数仓架构&#xff1a;离线数仓、实时数仓Lambda和Kappa、湖仓一体数据湖-CSDN博客 一文入门大数据准流式计算引擎Spark【万字详解&#xff0c;全网最新】_大数据 spark-CSDN博客 浅谈维度建…...

编程日记 2024/10/12 9:18:36

React 为什么 “虚拟 DOM 顶部有很多 provider“？

1、介绍React中的Context Provider 在 React 中&#xff0c;虚拟 DOM&#xff08;Virtual DOM&#xff09;是 React 用来高效更新 UI 的核心机制&#xff0c;它通过对比前后两次虚拟 DOM 树&#xff0c;确定哪些部分需要更新&#xff0c;以减少直接操作真实 DOM 的开销。而 “…...

编程日记 2024/10/12 9:17:35

忘记了 MySQL 8.0 的 root 密码，应该怎么办？

如果你忘记了 MySQL 8.0 的 root 密码&#xff0c;可以通过以下步骤来重置密码。请注意&#xff0c;这些步骤需要你有对 MySQL 服务器的物理或命令行访问权限。 步骤 1: 停止 MySQL 服务 首先&#xff0c;你需要停止正在运行的 MySQL 服务。你可以使用以下命令来停止 MySQL 服…...

编程日记 2024/10/12 9:14:30

Promise.reject()

Promise.reject() 静态方法返回一个已拒绝&#xff08;rejected&#xff09;的 Promise 对象&#xff0c;拒绝原因为给定的参数。 语法 Promise.reject(reason)参数 reason 该 Promise 对象被拒绝的原因。 返回值 返回一个已拒绝&#xff08;rejected&#xff09;的 Promi…...

编程日记 2024/10/12 9:13:27

大数据-163 Apache Kylin 全量增量Cube的构建 手动触发合并 JDBC 操作 Scala

点一下关注吧&#xff01;&#xff01;&#xff01;非常感谢&#xff01;&#xff01;持续更新&#xff01;&#xff01;&#xff01; 目前已经更新到了&#xff1a; Hadoop&#xff08;已更完&#xff09;HDFS&#xff08;已更完&#xff09;MapReduce&#xff08;已更完&am…...

编程日记 2024/10/12 9:09:23

云手机与传统手机的区别是什么？

随着科技的快速进步&#xff0c;云手机逐渐成为手机市场的热门选择。与传统的智能手机相比&#xff0c;云手机具有许多独特的功能和优势&#xff0c;尤其在多账号管理和高效操作方面备受关注。那么&#xff0c;云手机究竟与普通手机有哪些区别呢&#xff1f; 1. 更灵活的操作与…...

编程日记 2024/10/12 9:08:22

微知-Bluefield DPU命名规则各字段作用？BF2 BF3全系列命名大全

文章目录 背景字段命名C是bmc的意思NOT的N是是否加密S表示不加密但是secureboot enable倒数第四个都是E倒数第五个是速率 V和H是200GM表示E serials&#xff0c;H表示P serials&#xff08;区别参考兄弟篇&#xff1a;[more](https://blog.csdn.net/essencelite/article/detail…...

编程日记 2024/10/12 9:06:19

Ubuntu 上使用 Nginx 实现反向代理并启用 HTTPS（详细教程）

拒绝使用宝塔&#xff0c;虽然宝塔很好用方便&#xff0c;但是他非常占用资源&#xff0c;所以我正在尝试转换我使用服务器的方式&#xff0c;通过命令来才做这些&#xff0c;下面是我的详细步骤。 在这篇教程中&#xff0c;我们将详细介绍如何在 Ubuntu 系统上使用 Nginx 搭建…...

编程日记 2024/10/12 9:05:18

专业流媒体视频下载工具技术解析与使用指南

专业流媒体视频下载工具技术解析与使用指南 价值主张&#xff1a;高效解决流媒体内容本地化需求 在数字内容消费日益普及的今天&#xff0c;用户对在线视频资源的本地保存需求持续增长。m3u8-downloader作为一款专业的流媒体下载工具&#xff0c;专注于解决m3u8格式视频的高效…...

编程新知 2026/3/26 13:49:00

ChatTTS流式音频合成实战：从原理到高并发优化

最近在做一个智能客服项目&#xff0c;需要将AI生成的文本实时转换成语音播报给用户。一开始我们用的是传统的TTS服务&#xff0c;文本传过去&#xff0c;等它全部合成完&#xff0c;再把整个音频文件返回。在用户量不大的时候还好&#xff0c;但一到高峰期&#xff0c;问题就全…...

编程新知 2026/3/26 10:57:29

基于Qwen-2.5-VL与RAG的智能客服系统实战：从微调优化到生产部署

最近在做一个智能客服项目&#xff0c;客户那边对回答的准确性和时效性要求特别高。传统的规则引擎早就力不从心了&#xff0c;而直接用通用大模型&#xff0c;又经常“一本正经地胡说八道”&#xff0c;或者回答一些过时的信息。经过一番折腾&#xff0c;我们最终选择了 Qwen-…...

编程新知 2026/3/26 10:41:24

Mind+连接百度AI实战：手把手教你做一个能听会说的垃圾分类小助手

Mind与百度AI融合实战&#xff1a;打造智能垃圾分类助手的完整指南 在创客教育和STEAM领域&#xff0c;将硬件编程与人工智能结合已成为培养学生综合能力的新趋势。Mind作为一款图形化编程工具&#xff0c;以其低门槛和丰富的扩展库深受教育者和爱好者青睐。而百度AI开放平台提…...

编程新知 2026/3/26 7:08:08

别再只用命令行！Pycharm内置Database工具连接SQLite3的5个高效技巧（含文件路径避坑）

别再只用命令行&#xff01;Pycharm内置Database工具连接SQLite3的5个高效技巧&#xff08;含文件路径避坑&#xff09; 作为一名长期与SQLite3打交道的Python开发者&#xff0c;你是否还在反复切换终端和代码编辑器&#xff0c;用命令行执行sqlite3 test.db&#xff1f;或是为…...

编程新知 2026/3/26 6:27:36

终极M3U8下载神器：3步轻松掌握全网视频流保存技巧

终极M3U8下载神器&#xff1a;3步轻松掌握全网视频流保存技巧 M3U8 Downloader是一款强大的m3u8视频在线提取工具&#xff0c;专为流媒体下载设计&#xff0c;提供桌面客户端支持Windows和Mac系统。无论是在线课程、直播回放还是精彩影视内容&#xff0c;只需简单几步&#xf…...

编程新知 2026/3/26 5:30:16

想拥有专属的桌面宠物伙伴吗？DyberPet开源框架让个性化养成触手可及

想拥有专属的桌面宠物伙伴吗&#xff1f;DyberPet开源框架让个性化养成触手可及 【免费下载链接】DyberPet Desktop Cyber Pet Framework based on PySide6 项目地址: https://gitcode.com/GitHub_Trending/dy/DyberPet 你是否曾希望电脑桌面上能有一个可爱的虚拟伙伴&a…...

编程新知 2026/3/26 4:39:42

数据密集型文件的高效压缩技术：从原理到企业级解决方案

数据密集型文件的高效压缩技术&#xff1a;从原理到企业级解决方案 【免费下载链接】romm A beautiful, powerful, self-hosted rom manager 项目地址: https://gitcode.com/GitHub_Trending/rom/romm 一、问题溯源&#xff1a;为什么传统存储方案会失效&#xff1f; 在…...

编程新知 2026/3/26 2:39:04

【测试基础-Bug篇】09-测试用例的评审和测试执行之Bug定义及Bug生命周期及Bug管理流程

补充之前遗留的知识&#xff1a; 前面我们已经学习过了测试需求分析->测试用例的设计。 那现在我们先补充测试用例的评审和执行测试。测试用例的评审 对测试用例进行评审 评审的目的是什么&#xff1f; 关于用例的准确性&#xff1a;要求我们用例覆盖的需求跟项目的需求一致…...

编程新知 2026/3/26 0:44:38

DS3231/DS3232高精度RTC驱动设计与工业时间同步实践

1. DS323x_Generic 库深度技术解析&#xff1a;面向工业级时间同步的嵌入式RTC驱动设计1.1 高精度时间基准的工程必要性在嵌入式系统中&#xff0c;时间戳的准确性直接决定系统可靠性。传统MCU内置RTC&#xff08;如STM32的BKP域RTC&#xff09;在-40℃~85℃工业温度范围内月漂…...

编程新知 2026/3/26 0:24:30