pyspark 搭建多元线性回归算法 pytorch多元回归

转载

mob64ca1404baa2 2023-12-27 10:46:00

文章标签 pyspark 搭建多元线性回归算法深度学习 pytorch 逻辑回归读取数据 文章分类 Spark 大数据

文章目录

前言
一、训练集和测试集
二、步骤

1.引入库
2.读取数据
3.初始化模型参数
4.定义模型
5.定义损失函数
6.计算分类准确率
7.训练模型
8.预测

总结

前言

Softmax回归也称多项或多类的Logistic回归，是Logistic回归在多分类问题上的推广。

一、训练集和测试集

使用上一节获取得到的数据集Fashion-MNIST。

二、步骤

1.引入库

import torch
import torchvision
import numpy as np
import sys
sys.path.append("..") # 为了导入上层目录的d2lzh_pytorch
from d2lzh_pytorch import *
import d2lzh_pytorch as d2l

2.读取数据

batch_size =256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

d2l.load_data_fashion_mnist(batch_size)

该函数相当于把上一讲所作任务集成在一个函数中。
本函数已保存在d2lzh包中
def load_data_fashion_mnist(batch_size, resize=None, root='~/Datasets/FashionMNIST') trans = [] if resize: trans.append(torchvision.transforms.Resize(size=resize)) #因为resize=None所以不会执行这一步 trans.append(torchvision.transforms.ToTensor()) #转化为tensor形式 transform = torchvision.transforms.Compose(trans) #读取图像 mnist_train = torchvision.datasets.FashionMNIST(root=root, train=True, download=True, transform=transform) #上一讲有说，下载训练集数据 mnist_test = torchvision.datasets.FashionMNIST(root=root, train=False, download=True, transform=transform) #上一讲有说，下载测试集数据 if sys.platform.startswith('win'): num_workers = 0 # 0表示不用额外的进程来加速读取数据 else: num_workers = 4 #设置4个进程读取数据 train_iter = torch.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True, num_workers=num_workers) test_iter = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False, num_workers=num_workers) return train_iter, test_iter
以下是对第二个if语句的解释：
我们将在训练数据集上训练模型，并将训练好的模型在测试数据集上评价模型的表现。前面说过，mnist_train是torch.utils.data.Dataset的子类，所以我们可以将其传入torch.utils.data.DataLoader来创建一个读取小批量数据样本的DataLoader实例。
在实践中，数据读取经常是训练的性能瓶颈，特别当模型较简单或者计算硬件性能较高时。PyTorch的DataLoader中一个很方便的功能是允许使用多进程来加速数据读取。这里我们通过参数num_workers来设置4个进程读取数据。

3.初始化模型参数

num_inputs =784
num_outputs = 10

W = torch.tensor(np.random.normal(0, 0.01, (num_inputs,num_outputs)),
                 dtype=torch.float)
b = torch.zeros(num_outputs, dtype=torch.float)

W.requires_grad_(requires_grad=True)
b.requires_grad_(requires_grad=True)

4.定义模型

def softmax(X):
    X_exp = X.exp()
    partition = X_exp.sum(dim=1, keepdim=True)
    return X_exp / partition

def net(X):
    return softmax(torch.mm(X.view((-1, num_inputs)),W) + b)

X.exp()

返回e的X次方

X_exp.sum(dim=1, keepdim=True)

torch.sum()对输入的tensor数据的某一维度求和，一共两种用法
对其中同一列（dim=0）或同一行（dim=1）的元素求和，并在结果中保留行和列这两个维度（keepdim=True）。
.mm(）矩阵乘法 .view()重新定义矩阵的形状

5.定义损失函数

y_hat = torch.tensor([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]])
y = torch.LongTensor([0, 2])
y_hat.gather(1, y.view(-1, 1))

def cross_entropy(y_hat,y):
    return - torch.log(y_hat.gather(1, y.view(-1,1)))

.LongTensor()

转成longtensor类型

torch.gather(input, dim, index, out=None) → Tensor

返回的tensor的size与index的size一致。
dim用于指明index的元素值代表的维数。这个函数可以用来很方便地提取指定位置的元素。（提取房方阵，不是提取单个元素）

6.计算分类准确率

def accuracy(y_hat,y):
    return (y_hat.argmax(dim=1) == y).float().mean().item()

print(accuracy(y_hat, y))

.argmax(dim=1)

返回的是最大数的索引

.item()

python import torch x = torch.randn(2, 2) print(x) print(x[1,1]) print(x[1,1].item()) tensor([[ 0.4702, 0.5145], [-0.0682, -1.4450]]) tensor(-1.4450) -1.445029854774475
可以看出是显示精度的区别，item()返回的是一个浮点型数据，所以我们在求loss或者accuracy时，一般使用item()，而不是直接取它对应的元素x[1,1]。

# 本函数已保存在d2lzh_pytorch包中方便以后使用。该函数将被逐步改进：它的完整实现将在“图像增广”一节中描述
def evaluate_accuracy(data_iter, net):
    acc_sum, n = 0.0, 0
    for X, y in data_iter:
        acc_sum += (net(X).argmax(dim=1) == y).float().sum().item()
        n += y.shape[0]
    return acc_sum / n

7.训练模型

num_epochs, lr = 4, 0.1
train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, batch_size, [W, b], lr)

train_ch3()已保存在d2lzh包中
def train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size, params=None, lr=None, optimizer=None): for epoch in range(num_epochs): train_l_sum, train_acc_sum, n = 0.0, 0.0, 0 for X, y in train_iter: y_hat = net(X) l = loss(y_hat, y).sum() # 梯度清零 if optimizer is not None: optimizer.zero_grad() elif params is not None and params[0].grad is not None: for param in params: param.grad.data.zero_() l.backward() if optimizer is None: sgd(params, lr, batch_size) else: optimizer.step() # “softmax回归的简洁实现”一节将用到 train_l_sum += l.item() train_acc_sum += (y_hat.argmax(dim=1) == y).sum().item() n += y.shape[0] test_acc = evaluate_accuracy(test_iter, net) print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f' % (epoch + 1, train_l_sum / n, train_acc_sum / n, test_acc))

train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, batch_size, [W, b], lr)

net 模型
train_iter 训练数据
test_iter 测试数据
loss 损失值
num_epochs 训练循环次数
batch_size 批量大小
params=[W, b] 模型参数
lr 步长
optimizer=None

8.预测

X ,y = iter(test_iter).next()

true_labels = d2l.get_fashion_mnist_labels(y.numpy())
pred_labels = d2l.get_fashion_mnist_labels(net(X).argmax(dim=1).numpy())
titles = [true +'\n' + pred for true, pred in zip(true_labels, pred_labels)]

d2l.show_fashion_mnist(X[0:9], titles[0:9])