深度学习入门:mnist分类和boston房价预测的简单实现

---

一.波士顿房价预测

最终测试集上的RMSE为3.0702387288867223

• 下载数据集:sklearn上boston房价被封了,所以是从网上下载的

import numpy as np
import pandas as pd
import sklearn
import torch
import torch.utils.data as Data
import random

#获取数据集
dataset = pd.read_table('boston.txt', sep='\s+')
dataset=dataset.values

#按照 8:2 的比例划分训练集和测试集
train_size = int(len(dataset) * 0.8)
test_size = len(dataset)-train_size
train_dataset,test_dataset = Data.random_split(dataset,[train_size,test_size])
train_dataset=np.array(train_dataset)
test_dataset=np.array(test_dataset)
train_dataset=torch.tensor(train_dataset,dtype=torch.float32)
test_dataset=torch.tensor(test_dataset,dtype=torch.float32)
print(train_size,test_size)

• 数据归一化:我用的Z-score标准化

#对数据进行归一化:采取
train_features=train_dataset[:,:13]
train_labels=train_dataset[:,13]
test_features=test_dataset[:,:13]
test_labels=test_dataset[:,13]

train_mean=train_features.mean(axis=0).reshape(1,13)
train_std=train_features.std(axis=0).reshape(1,13)
test_mean=test_features.mean(axis=0).reshape(1,13)
test_std=test_features.std(axis=0).reshape(1,13)

train_features=(train_features-train_mean)/train_std
test_features=(test_features-test_mean)/test_std

• 定义所需的函数:数据迭代器,线性回归模型,均方差损失函数,随机梯度下降函数

def data_iter(batch_size,features,labels):
    num_examples=len(features)
    indices=list(range(num_examples))
    random.shuffle(indices)
    for i in range(0,num_examples,batch_size):
        batch_indices=torch.tensor(indices[i:min(i+batch_size,num_examples)])
        yield features[batch_indices],labels[batch_indices]
def LinearRegression(X,w,b):
    return torch.mm(X,w)+b
def squared_loss(y_hat,y):
    return (y_hat-y.reshape(y_hat.shape))**2/2
def sgd(params,lr,batch_size):
    with torch.no_grad():
        for param in params:
            param -= lr * param.grad /batch_size
            param.grad.zero_()

• 设置基本参数并直接开始优化w,b:

lr=0.01 #学习率
num_epochs=3 #整体迭代次数
batch_size=10 #每次使用的数据批量
net=LinearRegression
loss=squared_loss #使用的模型是线性回归模型
#初始化w,b
w=torch.normal(0,1,(13,1),requires_grad=True)
b=torch.zeros(1,requires_grad=True)

loss_y=[]#用于记录loss的数据画图


for epoch in range(num_epochs):
    for X,y in data_iter(batch_size,train_features,train_labels):
        y_hat=net(X,w,b)
        l=loss(y_hat,y)
        l.sum().backward()
        sgd((w,b),lr,batch_size)
    with torch.no_grad():#每次数据集整体迭代完后,计算整体的损失函数
        train_l = loss(net(train_features, w, b),train_labels)
        loss_y.append(train_l.detach().sum())
        print(f'epoch {
     epoch +