1. Python技术站首页
  2. 人工智能
  3. PyTorch

pytorch 常用线性函数详解

• PyTorch

PyTorch常用线性函数详解

在本文中，我们将介绍PyTorch中常用的线性函数，包括线性层、批归一化、Dropout和ReLU。我们还将提供两个示例，一个是使用线性层进行图像分类，另一个是使用批归一化进行图像分割。

线性层

线性层是一种将输入张量与权重矩阵相乘并加上偏置向量的操作。在PyTorch中，我们可以使用nn.Linear模块来实现线性层。以下是一个示例：

import torch
import torch.nn as nn

# Define input tensor
x = torch.randn(1, 784)

# Define linear layer
linear = nn.Linear(784, 10)

# Apply linear layer
y = linear(x)

# Print shape of output tensor
print(y.shape)

在这个示例中，我们首先定义了一个输入张量x，它的形状为(1, 784)。接下来，我们定义了一个线性层linear，它将输入张量的大小从(1, 784)转换为(1, 10)。然后，我们将输入张量x应用于线性层，并打印输出张量y的形状。

批归一化

批归一化是一种将输入张量的均值和方差归一化的操作。在PyTorch中，我们可以使用nn.BatchNorm2d模块来实现批归一化。以下是一个示例：

import torch
import torch.nn as nn

# Define input tensor
x = torch.randn(1, 64, 32, 32)

# Define batch normalization layer
batch_norm = nn.BatchNorm2d(64)

# Apply batch normalization
y = batch_norm(x)

# Print shape of output tensor
print(y.shape)

在这个示例中，我们首先定义了一个输入张量x，它的形状为(1, 64, 32, 32)。接下来，我们定义了一个批归一化层batch_norm，它将输入张量的每个通道的均值和方差归一化。然后，我们将输入张量x应用于批归一化层，并打印输出张量y的形状。

Dropout

Dropout是一种在训练过程中随机丢弃一些神经元的操作，以减少过拟合。在PyTorch中，我们可以使用nn.Dropout模块来实现Dropout。以下是一个示例：

import torch
import torch.nn as nn

# Define input tensor
x = torch.randn(1, 64, 32, 32)

# Define dropout layer
dropout = nn.Dropout(p=0.5)

# Apply dropout
y = dropout(x)

# Print shape of output tensor
print(y.shape)

在这个示例中，我们首先定义了一个输入张量x，它的形状为(1, 64, 32, 32)。接下来，我们定义了一个Dropout层dropout，它将输入张量的每个元素随机丢弃一定比例的概率。我们使用p=0.5来指定丢弃50%的概率。然后，我们将输入张量x应用于Dropout层，并打印输出张量y的形状。

ReLU

ReLU是一种常用的激活函数，它将所有负值都设置为零。在PyTorch中，我们可以使用nn.ReLU模块来实现ReLU。以下是一个示例：

import torch
import torch.nn as nn

# Define input tensor
x = torch.randn(1, 64, 32, 32)

# Define ReLU layer
relu = nn.ReLU(inplace=True)

# Apply ReLU
y = relu(x)

# Print shape of output tensor
print(y.shape)

在这个示例中，我们首先定义了一个输入张量x，它的形状为(1, 64, 32, 32)。接下来，我们定义了一个ReLU层relu，它将输入张量的所有负值都设置为零。我们使用inplace=True来指定在原地修改输入张量。然后，我们将输入张量x应用于ReLU层，并打印输出张量y的形状。

示例1：使用线性层进行图像分类

以下是使用线性层进行图像分类的示例代码：

import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision.datasets as datasets

# Define transformation
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
])

# Load dataset
train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
test_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)

# Define data loader
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=False)

# Define model
model = nn.Sequential(
    nn.Linear(3*32*32, 512),
    nn.ReLU(inplace=True),
    nn.Linear(512, 10)
)

# Define loss function and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

# Train model
for epoch in range(10):
    for i, (images, labels) in enumerate(train_loader):
        # Flatten images
        images = images.view(-1, 3*32*32)

        # Forward pass
        outputs = model(images)
        loss = criterion(outputs, labels)

        # Backward and optimize
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        # Print loss every 100 batches
        if (i+1) % 100 == 0:
            print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(epoch+1, 10, i+1, len(train_loader), loss.item()))

# Test model
with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in test_loader:
        # Flatten images
        images = images.view(-1, 3*32*32)

        # Forward pass
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)

        # Compute accuracy
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print('Accuracy of the model on the test images: {} %'.format(100 * correct / total))

在这个示例中，我们首先定义了一个变换transform，它将图像转换为张量并进行归一化。然后，我们加载了CIFAR10数据集，并定义了训练和测试数据加载器。接下来，我们定义了一个包含两个线性层和一个ReLU层的模型。我们使用交叉熵损失函数和随机梯度下降优化器来训练模型。最后，我们在测试集上测试模型，并打印准确率。

示例2：使用批归一化进行图像分割

以下是使用批归一化进行图像分割的示例代码：

import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision.datasets as datasets

# Define transformation
transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

# Load dataset
train_dataset = datasets.Cityscapes(root='./data', split='train', mode='fine', target_type='semantic', transform=transform)
test_dataset = datasets.Cityscapes(root='./data', split='test', mode='fine', target_type='semantic', transform=transform)

# Define data loader
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=16, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=16, shuffle=False)

# Define model
model = nn.Sequential(
    nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1),
    nn.BatchNorm2d(64),
    nn.ReLU(inplace=True),
    nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1),
    nn.BatchNorm2d(64),
    nn.ReLU(inplace=True),
    nn.MaxPool2d(kernel_size=2, stride=2),
    nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
    nn.BatchNorm2d(128),
    nn.ReLU(inplace=True),
    nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1),
    nn.BatchNorm2d(128),
    nn.ReLU(inplace=True),
    nn.MaxPool2d(kernel_size=2, stride=2),
    nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),
    nn.BatchNorm2d(256),
    nn.ReLU(inplace=True),
    nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
    nn.BatchNorm2d(256),
    nn.ReLU(inplace=True),
    nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
    nn.BatchNorm2d(256),
    nn.ReLU(inplace=True),
    nn.MaxPool2d(kernel_size=2, stride=2),
    nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),
    nn.BatchNorm2d(512),
    nn.ReLU(inplace=True),
    nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
    nn.BatchNorm2d(512),
    nn.ReLU(inplace=True),
    nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
    nn.BatchNorm2d(512),
    nn.ReLU(inplace=True),
    nn.MaxPool2d(kernel_size=2, stride=2),
    nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
    nn.BatchNorm2d(512),
    nn.ReLU(inplace=True),
    nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
    nn.BatchNorm2d(512),
    nn.ReLU(inplace=True),
    nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
    nn.BatchNorm2d(512),
    nn.ReLU(inplace=True),
    nn.MaxPool2d(kernel_size=2, stride=2),
    nn.ConvTranspose2d(512, 256, kernel_size=4, stride=2, padding=1),
    nn.BatchNorm2d(256),
    nn.ReLU(inplace=True),
    nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
    nn.BatchNorm2d(256),
    nn.ReLU(inplace=True),
    nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
    nn.BatchNorm2d(256),
    nn.ReLU(inplace=True),
    nn.ConvTranspose2d(256, 128, kernel_size=4, stride=2, padding=1),
    nn.BatchNorm2d(128),
    nn.ReLU(inplace=True),
    nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1),
    nn.BatchNorm2d(128),
    nn.ReLU(inplace=True),
    nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1),
    nn.BatchNorm2d(64),
    nn.ReLU(inplace=True),
    nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1),
    nn.BatchNorm2d(64),
    nn.ReLU(inplace=True),
    nn.Conv2d(64, 19, kernel_size=1, stride=1)
)

# Define loss function and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9, weight_decay=0.0005)

# Train model
for epoch in range(10):
    for i, (images, labels) in enumerate(train_loader):
        # Forward pass
        outputs = model(images)
        loss = criterion(outputs, labels)

        # Backward and optimize
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        # Print loss every 100 batches
        if (i+1) % 100 == 0:
            print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(epoch+1, 10, i+1, len(train_loader), loss.item()))

# Test model
with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in test_loader:
        # Forward pass
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)

        # Compute accuracy
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print('Accuracy of the model on the test images: {} %'.format(100 * correct / total))

在这个示例中，我们首先定义了一个变换transform，它将图像转换为张量并进行归一化。然后，我们加载了Cityscapes数据集，并定义了训练和测试数据加载器。接下来，我们定义了一个包含多个卷积层、批归一化层和反卷积层的模型。我们使用交叉熵损失函数和随机梯度下降优化器来训练模型。最后，我们在测试集上测试模型，并打印准确率。

总结

在本文中，我们介绍了PyTorch中常用的线性函数，包括线性层、批归一化、Dropout和ReLU，并提供了两个示例说明。这些技术对于图像分类和图像分割任务非常有用。

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：pytorch 常用线性函数详解 - Python技术站

赞 (0)
0 0 打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2023年5月16日
下一篇 2023年5月16日

相关文章

  • 利用Pytorch实现ResNet34网络 PyTorch

    利用Pytorch实现ResNet34网络

    利用Pytorch实现ResNet网络主要是为了学习Pytorch构建神经网络的基本方法，参考自«深度学习框架Pytorch:入门与实践»一书，作者陈云 1.什么是ResNet网络 ResNet(Deep Residual Network)深度残差网络，是由Kaiming He等人提出的一种新的卷积神经网络结构，其最重要的特点就是网络大部分是由如图一所示的残…

    2023年4月8日
    00

  • 使用pytorch测试单张图片（test single image with pytorch）

    以下代码实现使用pytorch测试一张图片 引用文章： https://www.learnopencv.com/pytorch-for-beginners-image-classification-using-pre-trained-models/ from __future__ import print_function, division from PI…

    PyTorch 2023年4月7日
    00
  • PyTorch DataLoader()使用 PyTorch

    PyTorch DataLoader()使用

    DataLoader的作用：通常在训练时我们会将数据集分成若干小的、随机的batch，这个操作当然可以手动操作，但是PyTorch里面为我们提供了API让我们方便地从dataset中获得batch，DataLoader就是干这事儿的。先看官方文档的描述，包括了每个参数的定义：它的本质是一个可迭代对象，一般的操作是： 创建一个dataset对象 创建一个Dat…

    2023年4月6日
    00
  • 动手学深度学习PyTorch版-task03 PyTorch

    动手学深度学习PyTorch版-task03

    课后习题 训练集、验证集和测试集的意义https://blog.csdn.net/ch1209498273/article/details/78266558有了模型后，训练集就是用来训练参数的，说准确点，一般是用来梯度下降的。而验证集基本是在每个epoch完成后，用来测试一下当前模型的准确率。因为验证集跟训练集没有交集，因此这个准确率是可靠的。那么为啥还需要…

    2023年4月8日
    00

  • PyTorch的Optimizer训练工具的实现

    PyTorch的Optimizer是一个用于训练神经网络的工具，它可以自动计算梯度并更新模型参数。本文将深入浅析PyTorch的Optimizer的实现方法，并提供两个示例说明。 1. PyTorch的Optimizer的实现方法 PyTorch的Optimizer的实现方法如下： optimizer = torch.optim.Optimizer(para…

    PyTorch 2023年5月15日
    00

  • pytorch单机多卡训练

    训练 只需要在model定义处增加下面一行： model = model.to(device) # device为0号 model = torch.nn.DataParallel(model) 载入模型 如果是多GPU载入，没有问题 如果训练时是多GPU，但是测试时是单GPU，会出现报错 解决办法

    PyTorch 2023年4月8日
    00

  • PyTorch全连接ReLU网络

    PyTorch全连接ReLU网络 1．PyTorch的核心是两个主要特征： 一个n维张量，类似于numpy，但可以在GPU上运行 搭建和训练神经网络时的自动微分/求导机制 本文将使用全连接的ReLU网络作为运行示例。该网络将有一个单一的隐藏层，并将使用梯度下降训练，通过最小化网络输出和真正结果的欧几里得距离，来拟合随机生成的数据。 2.张量 2.1 热身: …

    PyTorch 2023年4月8日
    00
  • Pytorch【直播】2019 年县域农业大脑AI挑战赛---初级准备(一)切图 PyTorch

    Pytorch【直播】2019 年县域农业大脑AI挑战赛—初级准备(一)切图

    比赛地址：https://tianchi.aliyun.com/competition/entrance/231717/introduction 这次比赛给的图非常大5万x5万，在训练之前必须要进行数据的切割。通常切割后的大小为512×512,或者1024×1024. 按照512×512切完后的结果如下： 切图时需要注意的几点是： gdal的二进制安装包wh…

    2023年4月6日
    00
合作推广
合作推广
分享本页
返回顶部