PyTorch入门（一）PyTorch基础、线性回归、Logistic回归和简单的神经网络

最新推荐文章于 2024-07-01 18:42:38 发布
最新推荐文章于 2024-07-01 18:42:38 发布
阅读量560 收藏 3
点赞数
分类专栏： PyTorch 文章标签： PyTorch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L18273121172/article/details/103325578
版权

PyTorch入门

PyTorch基础

forward 的使用与解释

类的 __call __() 函数

当把类当做函数调用进行使用时，会自动调用该类的 __call __() 函数。

例子如下：

class A():
    def __call__(self, param):
        
        print('i can called like a function')
        print('传入参数的类型是：{}   值为： {}'.format(type(param), param))
 
        res = self.forward(param)
        return res
 
    def forward(self, input_):
        print('forward 函数被调用了')
 
        print('in  forward, 传入参数类型是：{}  值为: {}'.format( type(input_), input_))
        return input_
 
a = A()
 
 
input_param = a('i')
print("对象a传入的参数是：", input_param)

输出

i can called like a function
传入参数的类型是：<class ‘str’> 值为： i
forward 函数被调用了
in forward, 传入参数类型是：<class ‘str’> 值为: i
对象a传入的参数是： i

forward

网络模型类一般会继承nn.Module父类，nn.Module父类中定义了__call__() 函数。
因此，在模型训练时，不需要使用forward，只要在实例化一个对象中传入对应的参数就可以自动调用 forward 函数

反向传播
  1. 标量的反向传播
    y.backward()
    不需要传入参数，相当于 y.backward(torch.Tensor([1]))
import torch

x = [[1,2],[3,4],[5,6]]
x = torch.Tensor(x)
x.requires_grad = True

y = 2*x*x
y = y.mean()    #此时y是一个标量，也就是0维张量
y.backward()
print(x.grad)

输出

tensor([[0.6667, 1.3333],
        [2.0000, 2.6667],
        [3.3333, 4.0000]])
  1. 矩阵/向量的反向传播
    y.backward ( 与矩阵 y 同维的Tensor )
import torch

x = [[1,2],[3,4],[5,6]]
x = torch.Tensor(x)
x.requires_grad = True

y = 2*x*x
y.backward(torch.ones(3,2))
print(x.grad)

输出

tensor([[ 4.,  8.],
        [12., 16.],
        [20., 24.]])
批训练数据

Mini-batch Training

批训练数据：每次训练神经网络时，不使用全部的训练集，只是用一小批数据

主要使用torch.utils.data.DataLoader函数进行分批次

loader = data.DataLoader(
    dataset=dataset,
    batch_size=BATCH_SIZE,
    shuffle=True    #每次分批次时重新打乱原来数据的顺序
)

import torch
import torch.utils.data as data   #用于批训练数据

BATCH_SIZE = 5

x= torch.linspace(1,10,10)
y = torch.linspace(1,10,10)

#自定义数据集
dataset = data.TensorDataset(x,y)
#使用DataLoader函数进行数据分批
loader = data.DataLoader(
    dataset=dataset,
    batch_size=BATCH_SIZE,
    shuffle=True
)
for epoch in range(3):
    for i,(data_x,data_y) in enumerate(loader):
        #training
        print('Epoch: ',epoch,'|第 %s 批次'%(i),'|data_x: ',data_x.numpy(),'|data_y: ',data_y.numpy())

批训练数据的输出结果：

Epoch:  0 |第 0 批次 |data_x:  [3. 1. 8. 5. 4.] |data_y:  [3. 1. 8. 5. 4.]
Epoch:  0 |第 1 批次 |data_x:  [ 2. 10.  7.  9.  6.] |data_y:  [ 2. 10.  7.  9.  6.]
Epoch:  1 |第 0 批次 |data_x:  [ 4.  2.  5.  3. 10.] |data_y:  [ 4.  2.  5.  3. 10.]
Epoch:  1 |第 1 批次 |data_x:  [6. 1. 8. 9. 7.] |data_y:  [6. 1. 8. 9. 7.]
Epoch:  2 |第 0 批次 |data_x:  [3. 9. 6. 5. 1.] |data_y:  [3. 9. 6. 5. 1.]
Epoch:  2 |第 1 批次 |data_x:  [ 8.  2.  4. 10.  7.] |data_y:  [ 8.  2.  4. 10.  7.]
常用优化器

  1. SGD
    随机梯度下降
    在这里插入图片描述
    SGD的噪音较BGD要多，使得SGD并不是每次迭代都向着整体最优化方向。所以虽然训练速度快，但是准 确度下降，并不是全局最优。虽然包含一定的随机性，但是从期望上来看，它是等于正确的导数的。

    优点：
    损失函数收敛速度比BGD快，每次只需要训练一批次的样本数据

    缺点
    1)SGD 因为更新比较频繁，会造成 cost function 有严重的震荡。
    2)SGD容易被困在鞍点处，只取得局部最小值
    在这里插入图片描述

  2. Momentum
    动量梯度下降法

    超参数设定值: 一般 β \beta β 取值 0.9 左右。

    优点：Momentum方法可以使得梯度方向不变的维度上更新速度变快，梯度方向改变的维度上更新速度变慢，从而相应地可以加快收敛和减小振荡。

    缺点：这种情况相当于小球从山上滚下来时是在盲目地沿着坡滚，如果它能具备一些先知，例如快要上坡时，就知道需要减速了的话，适应性会更好。

  3. RMSprop
    RMSprop是一种学习率自适应调节的方法，可以解决Adagrad中学习率急剧下降的问题
    RMSprop 使用的是指数加权平均，旨在消除梯度下降中的摆动，与Momentum的效果一样，某一维度的导数比较大，则指数加权平均就大，某一维度的导数比较小，则其指数加权平均就小，这样就保证了各维度导数都在一个量级，进而减少了摆动。允许使用一个更大的学习率η

    超参数设定值: 一般 β \beta β 取值 0.9 左右。

  4. Adam
    Adam方法是RMSprop + Momentum

    在网络训练的初始阶段时，Vdw和 Sdw 被初始化为 0 向量，那它们就会向 0 偏置，导致移动加权平均的结果和原值偏差较大，所以做了偏差校正，通过计算偏差校正后的 Vdw 和 Sdw 来抵消这些偏差：

    更新权重参数w

    超参数设定值: β1 ＝ 0.9，β2 ＝ 0.999， ε \varepsilon ε=10^-8

以线性回归模型为例测试优化器SGD、Momentum、RMSprop和Adam的性能

#测试优化器SGD、Momentum、RMSprop和Adam的性能
#以线性回归模型为例
import torch
import torch.nn as nn
import torch.utils.data as data
import torch.nn.functional as F
import matplotlib.pyplot as plt

#hyper parameters
LR = 0.01
EPOCH = 10
BATCH_SIZE = 25


#准备数据
x = torch.unsqueeze(torch.linspace(-1,1,1000),1)    #输入数据维度：1000*1
y = 2 * x * x + 0.1 * torch.randn(x.size())

dataset = data.TensorDataset(x,y)
loader = data.DataLoader(
    dataset = dataset,
    batch_size=BATCH_SIZE,
    shuffle=True
)

#构建网络
class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        self.hidden = nn.Linear(1,10)
        self.outputLayer = nn.Linear(10,1)

    def forward(self,x):
        x = F.relu(self.hidden(x))
        x = self.outputLayer(x)
        return x


netSGD = Net()
netMomentum = Net()
netRMSprop = Net()
netAdam = Net()
nets = [netSGD,netMomentum,netRMSprop,netAdam]
#定义损失函数和优化器

criterion = nn.MSELoss()

optim_SGD = torch.optim.SGD(netSGD.parameters(), lr = LR)
optim_Momentum = torch.optim.SGD(netMomentum.parameters(), lr = LR, momentum=0.8)
optim_RMSprop = torch.optim.RMSprop(netRMSprop.parameters(), lr = LR, alpha = 0.9)
optim_Adam = torch.optim.Adam(netAdam.parameters(),lr = LR, betas=(0.9,0.99))
optimizers = [optim_SGD,optim_Momentum,optim_RMSprop,optim_Adam]

losses_his = [[],[],[],[]]  #记录不同优化器对应模型的误差
#训练网络
for epoch in range(EPOCH):
    for steps,(data_x,data_y) in enumerate(loader):
        for net,optimizer,loss_his in zip(nets,optimizers,losses_his):
            optimizer.zero_grad()
            outputs = net(data_x)
            loss = criterion(outputs,data_y)
            loss.backward()
            optimizer.step()
            loss_his.append(loss)

print('Training finished!')
labels = ['SGD','Momentum','RMSprop','Adam']
for i in range(4):
    plt.plot(losses_his[i],label=labels[i])

plt.legend(loc = 'best')
plt.title('不同优化器的误差函数的比较',fontproperties = 'simHei')
plt.xlabel('steps')
plt.ylabel('Loss Function')
plt.show()
***
模型保存和加载

①保存和加载整个模型

#保存模型
torch.save(net, 'net.pkl')
#加载模型
net = torch.load('net.pkl')

②只保存模型中的参数

#保存模型参数
torch.save(net.state_dict(), 'net_parameters.pth')
#加载模型参数
net.load_state_dict(torch.load('net_parameters.pth'))
预训练模型的使用
#微调基础模型预训练
import torch
from torch import nn
from torchvision import models


#使用基础模型和预训练好的参数
pretrained_model = models.resnet18(pretrained = True)

#微调基础模型
#将最后一层全连接层的输出类别改为我们的类别
numclasses = 21
in_features = pretrained_model.fc.in_features
pretrained_model.fc = nn.Linear(in_features,numclasses)
GPU加速

将数据，模型和损失函数放到cuda平台上进行GPU加速

  • 数据：images = images.cuda()
  • 模型： net = net.cuda()
  • 损失函数： criterion = criterion.cuda()

线性模型

单变量线性回归

输入X是100×1的矩阵：只有1个特征，共有100个样本

网络模型共有两层：

  1. Hidden Layer: 10个隐藏单元
  2. Output Layer: 1个输出单元

Loss函数：均方误差函数（MSELoss）
优化器：随机梯度下降（SGD）

import torch
import torch.nn as nn
import torch.nn.functional as F
import matplotlib.pyplot as plt

x = torch.unsqueeze(torch.linspace(-1,1,100),dim = 1)
y = x * x + 0.05 * torch.randn(x.size())

# #绘制散点图
# plt.scatter(x.numpy(),y.numpy())
# plt.show()

#搭建网络
class Net(nn.Module):
    def __init__(self,n_features,n_hidden,n_ouputs):
        super(Net,self).__init__()
        self.hidden = nn.Linear(n_features,n_hidden)
        self.fc = nn.Linear(n_hidden,n_ouputs)


    def forward(self,x):
        x = F.relu(self.hidden(x))
        #输出层不用激活函数
        x = self.fc(x)
        return x

net = Net(1,10,1)

#定义损失函数和优化器

criterion = nn.MSELoss()
optimizer = torch.optim.SGD(net.parameters(),lr = 0.05)

plt.ion()

#训练网络
for epoch in range(2000):
    #清空优化器的梯度
    optimizer.zero_grad()
    #计算梯度：计算误差，反向传播
    outputs = net(x)
    loss  = criterion(outputs,y)
    loss.backward()
    #更新参数
    optimizer.step()

    if epoch % 5 == 0:
        # plot and show learning process
        plt.cla()
        plt.scatter(x.numpy(), y.numpy())
        plt.plot(x.numpy(), outputs.data.numpy(), 'r-', lw=5)
        plt.text(0.5, 0, 'Loss=%.4f' % loss.data.numpy(), fontdict={'size': 20, 'color':  'red'})
        plt.pause(0.1)

plt.ioff()
plt.show()

模型对于训练集的拟合曲线如下图：

损失函数图像

分类问题

二元分类问题

此次搭建的浅层神经网络只有两个输出单元，可以用于二分类问题

  1. 网络结构
    输入特征数：2个
    中间隐藏层：只有1层，每层有10个隐藏单元
    输出单元：2个
  2. Loss函数：交叉熵损失函数（CrossEntropyLoss）
  3. 优化器：Momentum优化器，梯度累计参数为 0.8
  4. 在测试集上的准确率
Accuracy of the net on the test set: 99.500 %

#Softmax Regression
import torch
import torch.nn as nn
import torch.nn.functional as F
import matplotlib.pyplot as plt
import numpy as np

# torch.manual_seed(1)    # reproducible

# make fake data
#training set
n_data = torch.ones(100, 2)
x0 = torch.normal(2*n_data, 1)      # class0 x data (tensor), shape=(100, 2)
y0 = torch.zeros(100)               # class0 y data (tensor), shape=(100, 1)
x1 = torch.normal(-2*n_data, 1)     # class1 x data (tensor), shape=(100, 2)
y1 = torch.ones(100)                # class1 y data (tensor), shape=(100, 1)
x = torch.cat((x0, x1), 0).type(torch.FloatTensor)  # shape (200, 2) FloatTensor = 32-bit floating
y = torch.cat((y0, y1), ).type(torch.LongTensor)    # shape (200,) LongTensor = 64-bit integer
#test set
test_x0 = torch.normal(2*n_data, 1)      # class0 x data (tensor), shape=(100, 2)
test_y0 = torch.zeros(100)               # class0 y data (tensor), shape=(100, 1)
test_x1 = torch.normal(-2*n_data, 1)     # class1 x data (tensor), shape=(100, 2)
test_y1 = torch.ones(100)                # class1 y data (tensor), shape=(100, 1)
test_x = torch.cat((test_x0, test_x1), 0).type(torch.FloatTensor)  # shape (200, 2) FloatTensor = 32-bit floating
test_y = torch.cat((test_y0, test_y1), ).type(torch.LongTensor)    # shape (200,) LongTensor = 64-bit integer
# plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=y.data.numpy(), s=100, lw=0, cmap='RdYlGn')
# plt.show()

#搭建网络
class Net(nn.Module):
    def __init__(self,n_features,n_units,n_ouputs):
        super(Net,self).__init__()
        self.fc1 = nn.Linear(n_features,n_units)
        self.fc2 = nn.Linear(n_units,n_ouputs)

    def forward(self,x):
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

net = Net(2,10,2)

#定义优化器和Loss函数

opitimizer = torch.optim.SGD(net.parameters(),lr = 0.1,momentum = 0.8)
criterion = nn.CrossEntropyLoss()

lossArray = []
#plt.ion()
#训练网络
for epoch in range(100):
    #梯度清空
    opitimizer.zero_grad()
    #计算梯度
    outputs = net(x)
    loss = criterion(outputs,y)
    loss.backward()
    #更新参数
    opitimizer.step()

    lossArray.append(loss)

    # if epoch % 2 == 0:
    #     plt.cla()
    #     _, predicted = torch.max(outputs,1)
    #     train_accuracy = (predicted == y).sum().item()/float(y.size(0))*100
    #     plt.scatter(x.numpy()[:, 0], x.numpy()[:, 1], c=predicted.numpy(), s=100, lw=0, cmap='RdYlGn')
    #     plt.text(1.5, -4, 'Accuracy=%.3f %%' % train_accuracy, fontdict={'size': 20, 'color':  'red'})
    #     plt.pause(0.01)

# plt.ioff()
# plt.show()

#测试网络
outputs = net(test_x)
_, predicted = torch.max(outputs,1)
test_accuracy = (predicted == test_y).sum().item()/float(test_y.size(0))
print('Accuracy of the net on the test set: %.3f %%'%(test_accuracy*100))
plt.subplot(2,1,1)
plt.scatter(x.numpy()[:, 0], x.numpy()[:, 1], c=y.numpy(), s=100, lw=0, cmap='RdYlGn')
plt.subplot(2,1,2)
plt.plot(np.linspace(1,100,100),lossArray)
plt.title('Loss Function Curve')
plt.xlabel('iteration')
plt.ylabel('Loss Function')
plt.show()

输入数据的分布与Loss函数曲线如下图：

多分类问题

搭建一个三层全连接层的神经网络，用于MNIST手写数字分类

  1. MNIST数据集：

    • 60000张训练图片，10000张测试图片
    • 数据集按照数字 0-9 分为10类
    • 图片格式：(1,28,28) 灰度图像，每张大小为 28 × \times × 28

  2. 网络结构：

 Net(
  (fc1): Sequential(
    (0): Linear(in_features=784, out_features=400, bias=True)
    (1): BatchNorm1d(400, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
  )
  (fc2): Sequential(
    (0): Linear(in_features=400, out_features=100, bias=True)
    (1): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
  )
  (fc3): Linear(in_features=100, out_features=10, bias=True)
)
  1. 准确率

  • Train set: Accuracy: 98.64 %

  • Test set: Accuracy: 97.75 %

由三层全连接层构成的神经网络在MNIST数据集的分类准确率可以达到 97.75%

  1. 损失函数图像如下图

代码如下：

#全连接层神经网络  -->  MNIST 手写数字分类
import torch
import  torch.nn as nn
import torch.utils.data as data
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt

#set hyper parameters
LR = 0.01
EPOCH = 20
BATCH_SIZE = 60
DOWNLOAD_MNIST = False

# prepare train_set and test_set
transforms = transforms.Compose([transforms.ToTensor(),
                                 transforms.Normalize([0.5],[0.5])])

train_set = torchvision.datasets.MNIST(root='./data/MNIST',
                                       train=True,
                                       transform = transforms,
                                       download=DOWNLOAD_MNIST)
train_loader = data.DataLoader(dataset=train_set,
                               batch_size=BATCH_SIZE,
                               shuffle=True)

test_set = torchvision.datasets.MNIST(root='./data/MNIST',
                                       train=False,
                                       transform = transforms,
                                       download=DOWNLOAD_MNIST)
test_loader = data.DataLoader(dataset=test_set,
                               batch_size=BATCH_SIZE,
                               shuffle=True)

# build the net
class Net(nn.Module):
    def __init__(self,n_features,n_hidden1,n_hidden2,n_outputs):
        super(Net, self).__init__()
        self.fc1 = nn.Sequential(nn.Linear(n_features,n_hidden1),
                                 nn.BatchNorm1d(n_hidden1),
                                 nn.ReLU())
        self.fc2 = nn.Sequential(nn.Linear(n_hidden1,n_hidden2),
                                 nn.BatchNorm1d(n_hidden2),
                                 nn.ReLU())
        self.fc3 = nn.Linear(n_hidden2,n_outputs)

    def forward(self,x):
        x = x.view(x.size(0),-1)
        x = self.fc1(x)
        x = self.fc2(x)
        x = self.fc3(x)
        return x

net = Net(28*28,400,100,10)
print('Net的结构：\n',net)

#define Loss Function and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=LR, betas=(0.9,0.99))

#train the net
correct_train = 0
total_train = 0
losses_his = []
for epoch in range(EPOCH):
    print('Epoch: ',epoch)
    for i, (images,labels) in enumerate(train_loader):
        #images: Tensor(60,1,28,28)
        #labels: Tensor(60)

        optimizer.zero_grad()
        outputs = net(images)
        loss = criterion(outputs,labels)
        loss.backward()
        optimizer.step()

        losses_his.append(loss)

        if (i+1) % 50 == 0:
            _, predicted = torch.max(outputs,1)
            correct_train +=(predicted == labels).sum().item()*50
            total_train += labels.size(0)*50
            accuracy = (predicted == labels).sum().item()/labels.size(0)
            print('Batch: [%d/%d]'%(i+1,60000/BATCH_SIZE),'|Loss: ',loss.item(),'|Accuracy: %.2f %%'%(accuracy*100))

accuracy_train = correct_train/total_train
print('Training Finished !\nTrain set: Accuracy: %.2f %%'%(accuracy_train*100))
torch.save(net.state_dict(),'./model/DNN_3Layers_MNIST.pkl')
print('The model trained is saved successfully!\n')

#test the net
num_correct = 0
total_test = 0
net.eval()
with torch.no_grad():
    for (images,labels) in test_loader:
        outputs = net(images)
        _, predicted = torch.max(outputs,1)
        num_correct += (predicted == labels).sum().item()
        total_test += labels.size(0)
    test_accuracy = num_correct/ total_test*100
print('Test set: Accuracy: %.2f %%'%(test_accuracy))

#visualization
plt.plot(losses_his)
plt.title('Loss Function Curve')
plt.xlabel('iteration')
plt.ylabel('Loss')
plt.show()
Ewards Liu
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Pytorch入门教程: 从线性回归到神经网络
LightningInSky的专栏
01-15 236
在这里，我们使用torch.tensor()函数来创建x和y张量，并设置它们的数据类型为torch.float32。在这里，我们使用for循环迭代1000次，在每次迭代中，我们首先计算预测值y_pred，然后计算损失函数loss。我们还使用optimizer.zero_grad()函数将梯度清零，然后使用loss.backward()函数计算梯度，最后使用optimizer.step()函数更新权重和偏置项。在这里，我们使用torch.matmul()函数将自变量x和权重w相乘，并将结果与偏置项b相加。
神经网络与PyTorch：线性回归
太子悦神的博客
11-09 1793
线性回归 1 一元线性回归 线性回归具有如下性质 y = x[0]w[0]+x[1]w[1]+…+x[m-1]w[m-1]+w[m] 其中w[0],w[1]…w[m-1],w[m]是m+1个权重值 线性回归是假设自变量和因变量之间的关系有这样子的形式，再利用数据确定出这m+1个权重值，最终找到自变量和因变量之间的关系。 1.1 最小二乘法 ​ 最小二乘法(Linear Least Squares, LLS) 是一种最基本的线性回归方法。在最小二乘回归中，有n条数据，每条数据有m个自变量数值x[i,0],x[
Pytorch——回归问题
12-22
文章目录1.前言2.数据准备3.搭建神经网络4.训练搭建的神经网络5.可视化操作 1.前言 我会这次会来见证神经网络是如何通过简单的形式将一群数据用一条线条来表示. 或者说, 是如何在数据当中找到他们的关系, 然后用神经网络模型来建立一个可以代表他们关系的线条. 2.数据准备 我们创建一些假数据来模拟真实的情况. 比如一个一元二次函数: y = a * x^2 + b, 我们给 y 数据加上一点噪声来更加真实的展示它. import torch import matplotlib.pyplot as plt #制造一些数据 x = torch.unsqueeze(torch.linspace(
pytorch 回归
易水寒
05-19 272
import torch from torch.autograd import Variable import torch.nn.functional as F import matplotlib.pyplot as plt x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim = 1) y = x.pow(2) + 0.2*torch.r...
PyTorch学习之torch.matmul函数
最新发布
qq_46396470的博客
07-01 402
用于两维或更高维张量的矩阵乘法操作。它支持广播机制，并且能够处理不同形状和维度的张量，适用于广泛的应用场景。
pytorch:回归
咩咩的博客
03-13 153
import torch from torch.autograd import Variable import torch.nn.functional as F import matplotlib.pyplot as plt x = torch.unsqueeze(torch.linspace(-1,1,100),dim=1) y = x.pow(2) + 0.2 * torch.rand(x.size()) x,y = Variable(x),Variable(y) #plt.scatter(x.d
PyTorch(线性回归)
weixin_43384504的博客
11-23 442
给你一堆数据点，这里用下面的图来表示： 假设用一条直线去拟合：y=kx+b; 1.问题转化成选择什么样子的k,b来拟合，怎么选择。 对于我们怎么来选择，是利用这个损失函数来表示的，损失函数中又有很多类型，这里就简单的用MSE（均方误差来表示）。 2.问题转...
pytorch回归模型
Andy_shenzl的博客
06-23 3674
数据简介 数据是常见的气温预测数据 先导入数据 features = pd.read_csv('temps.csv') features.head() year,moth,day,week分别表示的具体的时间 temp_2：前天的最高温度值 temp_1：昨天的最高温度值 average：在历史中，每年这一天的平均最高温度值 actual：这就是我们的标签值了，当天的真实最高温度 friend：这一列可能是凑热闹的，你的朋友猜测的可能值，咱们不管它就好了 我们需要把时间数据先进性简单的处理 #
Pytorch 基础——实现线性回归、逻辑回归和卷积神经网络
Chris Blog
03-27 2905
线性回归 1 步骤 构建一个类，叫做 LinearRegression 在这个类中定义模型 计算 MSE 均方误差损失函数 定义优化器 反向传播 预测 举个例子，我们有个汽车公司，如果车价格越低低，我们可以卖更多的车。 car_price_np = np.array([3,4,5,6,7,8,9], dtype=np.float32).reshape(-1,1) car_price_tenso...
PyTorch框架torch.nn实现Logistic回归
weixin_44940903的博客
08-11 1087
本文主要总结实现torch.nn实现Logistic回归的方法。Logistic回归[只借助Tensor和Numpy相关的库]在人工构造的数据集上进行训练和测试。
基于pytorch的logistic与softmax回归模型python代码
12-11
**基于PyTorch的Logistic与Softmax回归模型** 在深度学习领域，Logistic回归和Softmax回归是两种基础但非常重要的模型。...对于进阶学习者，可以在此基础上研究更复杂的模型，如神经网络和卷积神经网络。
具有神经网络思维的Logistic回归_逻辑回归_神经网络回归_具有神经网络思维的逻辑回归实现_
09-28
1. **逻辑回归基础**：逻辑回归模型基于线性回归，通过sigmoid函数将线性组合的权重和输入映射到(0,1)之间，输出为分类的概率。它的目标是最小化损失函数，通常选择的是二项逻辑回归损失或交叉熵损失。 2. **神经...
Pytorch-pytorch深度学习教程之逻辑回归.zip
05-22
2. **定义模型**：在PyTorch中，我们可以创建一个简单的逻辑回归模型，包含一个线性层（权重和偏置）以及sigmoid激活函数。模型类可能如下所示： ```python class LogisticRegression(nn.Module): def __init__...
pytorch实现回归算法
a_kou的博客
03-19 294
线性回归是机器学习中最基础和简单的算法，你可以将它视为深度学习界的 HelloWorld。如果不了解线性回归，你可以简单的理解为：训练一条直线，让这条直线拟合一些数据点的趋势。下面使用 PyTorch 实现一个简单的线性回归算法。# 导入自动梯度运算包，主要用Variable这个类。# 生成100个正态分布随机数，均值为0，方差为10。# 找到一条直线，使得它到所有点 的距离都很小。# 将Variable转换为数组，绘图。# 生成100个0---100间的数。# 反向传播 参数的更新。
线性回归（使用pytorch实现）
m0_59158839的博客
09-18 3845
线性回归（使用pytorch实现）
PyTorch实验—回归任务
xiaoxu的博客
06-03 2043
回归任务概述：通过pytorch搭建神经网络，进行气温的预测回归任务可以看作 y = kx + by为需要进行回归预测的值。
Pytorch 线性回归
あずにゃん梓喵的博客
07-30 281
日萌社 人工智能AI：Keras PyTorch MXNet TensorFlow PaddlePaddle 深度学习实战（不定时更新） Pytorch完成线性回归 目标 知道如何手动完成线性回归 1. 线性回归实现 下面，我们使用一个自定义的数据，来使用torch实现一个简单的线性回归 假设我们的基础模型就是y = wx+b，其中w和b均为参数，我们使用y = 3x+0.8来构...
pytorch实现回归模型
weixin_42318554的博客
12-14 2532
文章目录pytorch实现回归模型一、代码二、实现效果 pytorch实现回归模型 一、代码 import torch import torch.nn.functional as F import matplotlib.pyplot as plt #建立数据集 x = torch.unsqueeze(torch.linspace(-1,1,100),dim=1)# x data(tensor),shape(100,1) y = x.pow(2) + 0.2*torch.rand(x.size())#
Pytorch实现简单的回归
qq_34535410的博客
01-17 645
# -*- coding: utf-8 -*- # @Time : 2018/1/17 18:48 # @Author : Zhiwei Zhong # @Site : 回归 # @File : Regression.py # @Software: PyCharm import torch from torch.autograd import Variable import t
pytorch实现logistic回归
06-28
### 回答1： PyTorch实现Logistic回归的步骤如下： 1. 导入必要的库和数据集。 2. 定义模型：Logistic回归模型通常由一个线性层和一个sigmoid函数组成。 3. 定义损失函数：Logistic回归使用二元交叉熵作为损失函数。 4. 定义优化器：使用随机梯度下降（SGD）作为优化器。 5. 训练模型：使用训练数据集训练模型，并在每个epoch后计算损失函数和准确率。 6. 测试模型：使用测试数据集测试模型，并计算准确率。 7. 可视化结果：使用matplotlib库可视化训练和测试的损失函数和准确率。 下面是一个简单的PyTorch实现Logistic回归的示例代码： ``` import torch import torch.nn as nn import torch.optim as optim import matplotlib.pyplot as plt # 导入数据集 from sklearn.datasets import load_breast_cancer data = load_breast_cancer() X = data.data y = data.target # 将数据转换为张量 X = torch.tensor(X, dtype=torch.float32) y = torch.tensor(y, dtype=torch.float32) # 定义模型 class LogisticRegression(nn.Module): def __init__(self): super(LogisticRegression, self).__init__() self.linear = nn.Linear(X.shape[1], 1) self.sigmoid = nn.Sigmoid() def forward(self, x): x = self.linear(x) x = self.sigmoid(x) return x model = LogisticRegression() # 定义损失函数和优化器 criterion = nn.BCELoss() optimizer = optim.SGD(model.parameters(), lr=.01) # 训练模型 losses = [] accuracies = [] for epoch in range(100): # 前向传播 y_pred = model(X) # 计算损失函数和准确率 loss = criterion(y_pred, y.view(-1, 1)) accuracy = ((y_pred > .5).float() == y.view(-1, 1)).float().mean() # 反向传播和优化 optimizer.zero_grad() loss.backward() optimizer.step() # 记录损失函数和准确率 losses.append(loss.item()) accuracies.append(accuracy.item()) # 打印训练过程 print('Epoch [{}/{}], Loss: {:.4f}, Accuracy: {:.4f}'.format(epoch+1, 100, loss.item(), accuracy.item())) # 测试模型 with torch.no_grad(): y_pred = model(X) accuracy = ((y_pred > .5).float() == y.view(-1, 1)).float().mean() print('Test Accuracy: {:.4f}'.format(accuracy.item())) # 可视化结果 plt.plot(losses) plt.title('Training Loss') plt.xlabel('Epoch') plt.ylabel('Loss') plt.show() plt.plot(accuracies) plt.title('Training Accuracy') plt.xlabel('Epoch') plt.ylabel('Accuracy') plt.show() ``` 在这个示例中，我们使用了乳腺癌数据集作为示例数据集。我们首先将数据集转换为张量，然后定义了一个Logistic回归模型。我们使用二元交叉熵作为损失函数，使用随机梯度下降（SGD）作为优化器。我们训练模型并记录损失函数和准确率，然后使用测试数据集测试模型并计算准确率。最后，我们使用matplotlib库可视化训练和测试的损失函数和准确率。 ### 回答2： Logistic回归是一种二元分类算法，其主要目的是根据给定的输入数据，预测其所属的类别。在本文中，我们将介绍如何使用PyTorch来实现Logistic回归。 首先，我们需要导入必要的PyTorch库： import torch import torch.nn as nn import torch.optim as optim 然后，我们需要定义我们的数据集。这里我们假设我们有n个数据样本，每个样本包含m个特征和一个二元类别。我们可以将这些数据存储在两个PyTorch张量中：一个包含特征，一个包含类别标签。 x = torch.randn(n, m) # 特征张量 y = torch.randint(high=2, size=(n, 1)).float() # 类别标签张量 接下来，我们需要定义我们的Logistic回归模型。这里我们将使用一个包含单个线性层的简单神经网络，以及一个sigmoid激活函数。 class LogisticRegression(nn.Module): def __init__(self, input_size): super(LogisticRegression, self).__init__() self.linear = nn.Linear(input_size, 1) def forward(self, x): output = self.linear(x) output = torch.sigmoid(output) return output model = LogisticRegression(m) 接下来，我们需要定义我们的损失函数和优化器。对于Logistic回归，通常使用二元交叉熵作为损失函数，使用随机梯度下降作为优化器。 criterion = nn.BCELoss() optimizer = optim.SGD(model.parameters(), lr=0.1) 现在我们可以开始训练我们的模型了。首先，我们将定义训练的迭代次数。然后，我们将循环n_epochs次并在每次迭代中计算模型的损失和梯度，并使用优化器更新模型参数。 n_epochs = 1000 for epoch in range(n_epochs): # 前向传播 y_pred = model(x) # 计算损失 loss = criterion(y_pred, y) # 反向传播 optimizer.zero_grad() loss.backward() optimizer.step() # 输出当前损失 if epoch % 100 == 0: print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, n_epochs, loss.item())) 最后，我们可以使用训练好的模型预测新的数据。我们只需要将数据传递给模型，然后将输出映射到二元类别。 with torch.no_grad(): y_pred = model(new_data) prediction = (y_pred >= 0.5).float() print('Prediction:', prediction) 总的来说，使用PyTorch实现Logistic回归非常简单。我们只需要定义模型，损失函数和优化器，然后使用反向传播更新模型参数。当然，在实现Logistic回归模型时还有许多其他的考虑因素，例如数据预处理和超参数调整，但这些在这篇文章里并没有讨论。 ### 回答3： pytorch是一个开源的机器学习框架，它可以帮助我们快速实现各种机器学习算法。其中，logistic回归是一个经典的二分类算法，我们可以使用pytorch来实现它。 首先，我们需要准备好数据集。通常情况下，我们会将数据集划分为训练集和测试集，用训练集来训练模型，用测试集来测试模型的性能。 然后，我们需要定义模型。对于logistic回归来说，模型通常只有一层线性层和一个sigmoid激活函数。这可以通过pytorch中的nn.Linear和nn.Sigmoid来实现。 接下来，我们需要定义损失函数和优化器。对于logistic回归来说，常用的损失函数是二元交叉熵损失函数。优化器可以选择随机梯度下降法。 然后，我们可以通过迭代训练集中的样本来训练模型。具体来说，对于每一个样本，我们需要调用模型来预测其所属类别，计算预测值和真实值之间的误差，并根据误差更新模型的参数。这可以通过pytorch中的backward和step方法来实现。 最后，我们可以使用测试集来测试模型的性能。具体来说，对于每一个样本，我们需要调用模型来预测其所属类别，并将预测结果和真实值进行比较，计算分类准确率。 以上就是用pytorch实现logistic回归的基本步骤。当然，实际应用中还有很多需要注意和优化的地方，比如数据预处理、超参数调整等等。但是掌握了基本的实现方法，我们就可以应用pytorch来实现各种机器学习算法了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值