PythonGuides-博客中文翻译-十四-
PythonGuides 博客中文翻译（十四）
PyTorch 批处理规范化
在本 Python 教程中，我们将学习 python 中的 PyTorch 批处理规范化，我们还将涵盖与使用 PyTorch 进行批处理规范化相关的不同示例。我们将讨论这些话题。
- PyTorch 批处理规范化
- PyTorch 批处理规范化示例
- PyTorch 批处理规范化实现
- PyTorch 批次标准化 1d
- PyTorch 批处理规范化 2d
- PyTorch 批量标准化 3d
- PyTorch 批量标准化 lstm
- PyTorch 批处理规范化 conv2d
- PyTorch 批量标准化运行均值
- PyTorch 批处理规范化评估模式
目录
- PyTorch 批量归一化
- PyTorch 批量标准化示例
- PyTorch 批量归一化实现
- PyTorch 批量标准化 1d
- PyTorch 批量标准化 2d
- PyTorch 批量标准化 3d
- PyTorch 批量标准化 lstm
- PyTorch 批量标准化 conv2d
- PyTorch 批量归一化运行均值
- PyTorch 批量标准化评估模式
PyTorch 批量归一化
在这一节中，我们将学习在 python 中 bach 规范化是如何工作的。为了实现，我们将使用 PyTorch Python 包。
- 批量标准化被定义为训练神经网络的过程，该神经网络对每个小批量的层的输入进行标准化。
- 这个过程稳定了学习过程，也减少了训练模型所需的历元数。
代码:
在下面的代码中，我们将导入一些库，从中我们可以训练深度神经网络。
- nn。BatchNorm1d 用于将数据归一化为 0 均值和单位方差。
- inputval = torch.randn(22，102) 用于生成随机数。
outputval = n(input)用于得到输出值。print(outputval)用于在屏幕上打印输出。
import torch
import torch.nn as nn
n = nn.BatchNorm1d(102)
**# Without Learnable Parameters**
n = nn.BatchNorm1d(102, affine=False)
inputval = torch.randn(22, 102)
outputval = n(input)
print(outputval)
输出:
运行上面的代码后，我们得到下面的输出，从中我们可以看到屏幕上的批处理规范化已经完成。
Pytorch batch normalization
另外，检查: PyTorch 保存模型
PyTorch 批量标准化示例
在本节中，我们将了解 PyTorch 批处理规范化示例如何在 python 中运行。
Pytorch 批处理规范化是训练神经网络的过程。在训练网络期间，这一层继续猜测其计算的平均值和方差。
代码:
在下面的代码中，我们将导入一些库，从这些库中我们可以训练神经网络，还可以评估它的计算平均值和方差。
- nn。(flatten())用来定义一个连续的 dim 成张量的范围。
- nn。线性()用于创建一个前馈网络。
- nn。BatchNorm1d() 用于将数据归一化为 0 均值和单位方差。
torch.manual_seed(44)用于设置固定随机数种子。MLP = Multilayerpercepron()用于初始化多层感知器。currentloss = 0.0用于设置当前损耗值。optimizer.zero_grad()用于将梯度归零。
import torch
import os
from torch import nn
from torchvision.datasets import CIFAR10
from torch.utils.data import DataLoader
from torchvision import transforms
class Multilayerpercepron(nn.Module):
def __init__(self):
super().__init__()
self.layers = nn.Sequential(
nn.Flatten(),
nn.Linear(32 * 32 * 3, 64),
nn.BatchNorm1d(64),
nn.ReLU(),
nn.Linear(64, 32),
nn.BatchNorm1d(32),
nn.ReLU(),
nn.Linear(32, 10)
)
def forwardfun(self, y):
'''Forward pass'''
return self.layers(y)
if __name__ == '__main__':
torch.manual_seed(44)
# Prepare CIFAR-10 dataset
dataset = CIFAR10(os.getcwd(), download=True, transform=transforms.ToTensor())
trainloader = torch.utils.data.DataLoader(dataset, batch_size=10, shuffle=True, num_workers=1)
mlp = Multilayerpercepron()
# Define the loss function and optimizer
lossfunction = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(mlp.parameters(), lr=1e-4)
# Run the training loop
for epoch in range(0, 7):
# Print epoch
print(f'Starting epoch {epoch+1}')
currentloss = 0.0
# Iterate over the DataLoader for training data
for i, data in enumerate(trainloader, 0):
# Get inputs
inputs, targets = data
optimizer.zero_grad()
# Perform forward pass
outputs = mlp(inputs)
# Compute loss
loss = lossfunction(outputs, targets)
# Perform backward pass
loss.backward()
# Perform optimization
optimizer.step()
# Print statistics
currentloss += loss.item()
if i % 502 == 499:
print('Loss after mini-batch %5d: %.3f' %
(i + 1, currentloss / 502))
currentloss = 0.0
print('Training process has been finished.')
输出:
在下面的输出中，我们可以看到训练神经网络对每个小批量的层输入进行标准化，同时减少了历元的数量。
Pytorch batch normalization example
另外，请阅读:Python 中的 tensor flow
PyTorch 批量归一化实现
在本节中，我们将了解如何在 Python 中实现 PyTorch 批处理规范化。
PyTorch 批量标准化实现用于训练深度神经网络，该网络对每个小批量的层的输入进行标准化。
代码:
在下面的代码中，我们将导入一些库，从中我们可以实现批量规范化。
- train _ dataset =数据集。使用 MNIST() 作为训练数据集。
- 测试数据集=数据集。使用 MNIST() 作为测试数据集。
- nn。BatchNorm2d() 作为从最后一层输出并进入批量定额层的维数。
- nn。Dropout() 用作神经网络中的一个脱落单元。
torch.flatten()通过将其整形为一维张量，用作更平坦的输入。- test _ loss+= f . nll _ loss(output，label，reduction='sum ')。项用于计算测试损失。
- pred=output.argmax(dim=1，keepdim=True) 用于预测输出。
- 精度+=pred.eq(label.view_as(pred))。sum()。项用于预测准确度。
- 打印(' \ n 测试集:平均损耗:{:.6f}，精度:{} '。format( test_loss，accuracy)) 用于打印测试集。
import torch
import torch.nn as nn
import torch.nn.functional as fun
import torch.optim as opt
from torchvision import datasets,transforms
from torch.optim.lr_scheduler import StepLR
torch.manual_seed(52)
batch_size=34
epochs=12
lr=0.01
is_cuda=torch.cuda.is_available()
device=torch.device("cuda" if is_cuda else "cpu")
print(device)
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1309,),(0.3082,))])
train_dataset=datasets.MNIST('../data',train=True,download=True,transform=transform)
test_dataset=datasets.MNIST('../data',train=False,transform=transform)
train_loader=torch.utils.data.DataLoader(train_dataset,batch_size)
test_loader=torch.utils.data.DataLoader(test_dataset,batch_size)
class model(nn.Module):
def __init__(self):
super(model,self).__init__()
self.conv=nn.Conv2d(1,32,3,1)
self.conv_bn=nn.BatchNorm2d(32)
self.conv1=nn.Conv2d(32,64,3,1)
self.conv1_bn=nn.BatchNorm2d(64)
self.dropout=nn.Dropout(0.25)
self.fc=nn.Linear(9216,128)
self.fc_bn=nn.BatchNorm1d(128)
self.fc1=nn.Linear(128,10)
def forwardfun(self,y):
y=self.conv(y)
y=fun.relu(self.conv_bn(y))
y=self.conv1(y)
y=fun.relu(self.conv1_bn(y))
y=fun.max_pool2d(y,2)
y=self.dropout(y)
y=torch.flatten(y,1)
y=self.fc(y)
y=fun.relu(self.fc_bn(y))
y=self.fc1(y)
output=fun.log_softmax(y,dim=1)
return output
model=model().to(device)
print(model)
optimizer=opt.Adadelta(model.parameters(),lr=lr)
def train(epoch):
model.train()
for batch_id,(image,label) in enumerate(train_loader):
image,label=image.to(device),label.to(device)
optimizer.zero_grad()
output=model(image)
loss=fun.nll_loss(output,label)
loss.backward()
optimizer.step()
if batch_id % 1000==0:
print('Train Epoch: {} \tLoss: {:.8f}'.format(epoch,loss.item()))
def test():
model.eval()
test_loss=0
accuracy=0
with torch.no_grad():
for image,label in test_loader:
image,label=image.to(device),label.to(device)
output=model(image)
test_loss+=fun.nll_loss(output,label,reduction='sum').item()
pred=output.argmax(dim=1,keepdim=True)
accuracy+=pred.eq(label.view_as(pred)).sum().item()
test_loss/=len(test_loader.dataset)
print('\nTest Set: Average loss: {:.6f}, Accuracy: {}'.format(
test_loss, accuracy))
#after batch normalization
scheduler=StepLR(optimizer,step_size=1,gamma=0.7)
for epoch in range(1,epochs+1):
train(epoch)
test()
scheduler.step()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到火车历元丢失被打印在屏幕上。
PyTorch batch normalization implementation
阅读:蟒蛇皮里的熊猫
PyTorch 批量标准化 1d
在本节中，我们将学习 python 中的 PyTorch 批处理规范化 1d 。
PyTorch batch normalization 1d 是一种用于更快、更稳定地构建神经网络的技术。
语法:
下面的语法属于批处理规范化 1d。
torch.nn.BatchNorm1d(num_features,eps=1e-05,momentum=0.1,affine=True,track_running_status=True,device=None,dtype=None)
批量标准化 1d 中使用的参数:
num_features被定义为 C 期望输入的尺寸(N，C，L)。eps用作演示器，为数值稳定性添加一个值。- 动量用作 running_mean 和 running_var 计算值。
- 仿射被定义为一个布尔值，如果该值被设置为真，则该模块具有可学习的仿射参数。
track_running_status被定义为一个布尔值，如果该值设置为 true，则该模块跟踪运行平均值和方差。如果该值设置为 false，则该模块不会跟踪运行平均值和方差。
示例:
在下面的例子中，我们将导入一些库，我们将从这些库中创建批处理规范化 1d。
- a = nn。BatchNorm1d(120) 是一个可学习的参数。
- a = nn。BatchNorm1d(120，affine=False) 用作无学习参数。
- inputs = torch.randn(40，120) 用于生成随机输入。
- 打印(输出)用于打印输出值。
import torch
from torch import nn
a = nn.BatchNorm1d(120)
a = nn.BatchNorm1d(120, affine=False)
inputs = torch.randn(40, 120)
outputs = a(inputs)
print(outputs)
输出:
在下面的输出中，我们可以看到屏幕上打印了批处理归一化 1d 值。
PyTorch batch normalization 1d
PyTorch 批量标准化 2d
在本节中，我们将学习 python 中的 PyTorch 批处理规范化 2d 。
PyTorch 批处理规范化 2d 是一种构造深度神经网络的技术，批处理 norm2d 应用于 4D 输入之上的批处理规范化。
语法:
下面的语法是批处理规范化 2d。
torch.nn.BatchNorm2d(num_features,eps=1e-05,momentum=0.1,affine=True,track_running_statats=True,device=None,dtype=None)
自然归一化 2d 中使用的参数:
num_features被定义为 C 期望输入的尺寸(N，C，H，W)。eps用作演示器，为数值稳定性添加一个值。- 动量用作 running_mean 和 running_var 计算值。
- 仿射被定义为一个布尔值，如果该值被设置为真，则该模块具有可学习的仿射参数。
track_running_status被定义为一个布尔值，如果该值设置为 true，则该模块跟踪运行平均值和方差。如果该值设置为 false，则该模块不会跟踪运行平均值和方差。
举例:
在下面的例子中，我们将导入一些库，我们将从这些库中创建批处理规范化 2d。
- a = nn。BatchNorm2d(120) 与可学习参数一起使用。
- a = nn。使用 BatchNorm2d(120，affine=False) 时没有可学习的参数。
- inputs = torch.randn(20，120，55，65) 用于生成随机数。
- outputs = a(输入)用于得到输出。
- 打印(输出)用于打印输出。
import torch
from torch import nn
a = nn.BatchNorm2d(120)
a = nn.BatchNorm2d(120, affine=False)
inputs = torch.randn(20, 120, 55, 65)
outputs = a(inputs)
print(outputs)
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到 PyTorch 批处理规范化 2d 数据打印在屏幕上。
PyTorch batch normalization 2d
PyTorch 批量标准化 3d
在本节中，我们将学习 python 中的 PyTorch 批处理规范化 3d 。
PyTorch bach normalization 3d 被定义为创建深度神经网络的过程，bachnorm3d 被应用于 5D 输入之上的批量归一化。
语法:
以下语法属于批量规范化 3d。
torch.nn.BatchNorm3d(num_features,eps=1e-05,momentum=0.1,affine=True,track_running_status=True,device=None,dtype=None)
批量归一化 3d 中使用的参数:
num_features定义为 C 预期输入的尺寸(N，C，D，H，W)。eps用作演示器，为数值稳定性添加一个值。- 动量用作 running_mean 和 running_var 计算值。
- 仿射被定义为一个布尔值，如果该值被设置为真，则该模块具有可学习的仿射参数。
track_running_status被定义为一个布尔值，如果该值设置为 true，则该模块跟踪运行平均值和方差。如果该值设置为 false，则该模块不会跟踪运行平均值和方差。
举例:
在以下示例中，我们将导入一些库，从中我们可以创建一个批量标准化 3d。
- a = nn。BatchNorm3d(130) 与可学习参数一起使用。
- a = nn。BatchNorm3d(130，affine=False) 在没有可学习参数的情况下使用。
- inputs = torch.randn(50，130，65，75，40) 用于生成随机数的输入。
- 打印(输出)用于打印输出。
import torch
from torch import nn
a = nn.BatchNorm3d(130)
a = nn.BatchNorm3d(130, affine=False)
inputs = torch.randn(50, 130, 65, 75, 40)
outputs = a(inputs)
print(outputs)
输出:
运行上述代码后，我们得到以下输出。在输出中，我们可以看到 BatchNorm3d 应用于 5D 输入上面的批处理归一化 3d，并且输出被打印在屏幕上。
PyTorch batch normalization 3d
PyTorch 批量标准化 lstm
在本节中，我们将学习 python 中的 PyTorch 批处理规范化 lstm 。
LSTM代表长短期记忆。LSTM是一类递归神经网络，递归神经网络是一类人工神经网络。- 在 PyTorch 中，批量标准化 lstm 被定义为自动标准化深度神经网络层输入的过程。
代码:
在下面的代码中，我们将导入一些库，从中我们可以创建深度神经网络，并自动将输入规范化到层。
- nn。Flatten() 通过将其重新整形为一维张量来用作 Flatten 输入。
- nn。线性()用于创建一个前馈网络。
torch.manual_seed(44)用于设置固定的随机种子数。dataset = CIFAR10()用于准备一个 CIFAR-10 数据集。mlp = mlp()用于初始化多层感知器。- 损失函数= nn。用来定义损失函数。
- print(f ' starting epoch { epoch+1 } ')用于打印 epoch。
currentloss = 0.0用于设置当前损耗值。- loss = lossfunction(output，target) 用于计算损失。
loss.backward()用于执行向后传递。optimizer . step()用于执行优化。
import torch
import os
from torch import nn
from torchvision.datasets import CIFAR10
from torch.utils.data import DataLoader
from torchvision import transforms
class mlp(nn.Module):
def __init__(self):
super().__init__()
self.layers = nn.Sequential(
nn.Flatten(),
nn.Linear(32 * 32 * 3, 64),
nn.BatchNorm1d(64),
nn.ReLU(),
nn.Linear(64, 32),
nn.BatchNorm1d(32),
nn.ReLU(),
nn.Linear(32, 10)
)
def forwardfun(self, y):
'''Forward pass'''
return self.layers(y)
if __name__ == '__main__':
torch.manual_seed(44)
dataset = CIFAR10(os.getcwd(), download=True, transform=transforms.ToTensor())
trainloader = torch.utils.data.DataLoader(dataset, batch_size=10, shuffle=True, num_workers=1)
mlp = mlp()
lossfunction = nn.CrossEntropyLoss()
optimizers = torch.optim.Adam(mlp.parameters(), lr=1e-4)
**
# Run the training loop**
for epoch in range(0, 10):
print(f'Starting epoch {epoch+1}')
currentloss = 0.0
**# Iterate over the DataLoader for training data**
for i, data in enumerate(trainloader, 0):
input, target = data
optimizers.zero_grad()
output = mlp(input)
loss = lossfunction(output, target)
loss.backward()
optimizers.step()
# Print statistics
currentloss += loss.item()
if i % 550 == 499:
print(' Loss After Mini-batch %5d: %.3f' %
(i + 1, currentloss / 550))
currentloss = 0.0
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 批处理规范化 lstm 打印在屏幕上。
PyTorch batch normalization lstm
阅读 PyTorch 逻辑回归
PyTorch 批量标准化 conv2d
在本节中，我们将了解 python 中的 PyTorch 批处理规范化 conv2d 如何工作。
- 在继续前进之前，应该了解一下关于
conv2d的知识。conv2d是一个 2d 卷积层，用于创建卷积内核。 - 它还与层输入绑定，并有助于产生张量输出。
- 批处理规范化是一种使神经网络更快、更稳定的技术。
代码:
在下面的代码中，我们将导入一些库，在 conv2d 的帮助下，我们可以从这些库中创建一个神经网络。
- 变换=变换。Compose() 用于转换数据。
- train _ dataset =数据集。MNIST() 用于创建训练数据集。
- 测试数据集=数据集。MNIST() 用于创建测试数据集。
- train _ loader = torch . utils . data . data loader()用于加载列车数据。
test _ loader = torch . utils . data . data loader()用于加载测试数据。- nn。BatchNorm2d() 作为从最后一层输出并进入批量定额层的维数。
- nn。Dropout() 用作神经网络中的一个脱落单元。
torch.flatten()通过将其整形为一维张量，用作更平坦的输入。
import torch
import torch.nn as nn
import torch.nn.functional as fun
import torch.optim as opt
from torchvision import datasets,transforms
from torch.optim.lr_scheduler import StepLR
torch.manual_seed(52)
batch_size=34
epochs=12
lr=0.01
is_cuda=torch.cuda.is_available()
device=torch.device("cuda" if is_cuda else "cpu")
print(device)
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1309,),(0.3082,))])
train_dataset=datasets.MNIST('../data',train=True,download=True,transform=transform)
test_dataset=datasets.MNIST('../data',train=False,transform=transform)
train_loader=torch.utils.data.DataLoader(train_dataset,batch_size)
test_loader=torch.utils.data.DataLoader(test_dataset,batch_size)
class model(nn.Module):
def __init__(self):
super(model,self).__init__()
self.conv=nn.Conv2d(1,32,3,1)
self.conv_bn=nn.BatchNorm2d(32)
self.conv1=nn.Conv2d(32,64,3,1)
self.conv1_bn=nn.BatchNorm2d(64)
self.dropout=nn.Dropout(0.25)
self.fc=nn.Linear(9216,128)
self.fc_bn=nn.BatchNorm1d(128)
self.fc1=nn.Linear(128,10)
def forwardfun(self,y):
u=self.conv1(y)
y=fun.relu(self.conv1_bn(y))
y=self.conv2(y)
y=fun.relu(self.conv2_bn(y))
y=fun.max_pool2d(y,2)
y=self.dropout1(y)
y=torch.flatten(y,1)
y=self.fc(y)
y=fun.relu(self.fc_bn(y))
y=self.fc1(y)
output=fun.log_softmax(y,dim=1)
return output
model=model().to(device)
print(model)
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到卷积层与输入绑定，并有助于产生张量输出。
PyTorch batch normalization conv2d
PyTorch 批量归一化运行均值
本节我们将学习如何在 Python 中计算 PyTorch 批处理规范化运行均值。
- PyTorch 批量归一化运行均值定义为训练神经网络的过程。
- 在训练层保持运行期间，并且在运行过程中，他们估计计算的平均值。
代码:
在下面的代码中，我们将导入一些库，从中我们可以计算运行平均值。
index _ average _ factor = 1.0/float(self . num _ batches _ tracked)是使用累计移动平均线。- 指数平均因子=自动量采用指数移动平均。
- var = input.var([0，2，3]，无偏=假)是在训练中使用的偏置 var。
- self . running_var = exponential _ average _ factor * var * m/(m–1)+(1-exponential _ average _ factor) self . running _ var*用于用无偏 var 更新 running _ var。
print(" printing bn1 running mean from NET during forward ")用于打印输出。
import torch
import torch.nn as nn
import torch.nn.functional as fun
import torch.optim as opt
from torch.distributions import uniform
import torch.backends.cudnn as cudnn
import torchvision
import torchvision.transforms as transforms
from torch.nn.parameter import Parameter
class BatchNorm2d(nn.BatchNorm2d):
def __init__(self, num_features, eps=1e-5, momentum=0.1,
affine=True, track_running_stats=True):
super(BatchNorm2d, self).__init__(
num_features, eps, momentum, affine, track_running_stats)
def forward(self, input):
self._check_input_dim(input)
exponential_average_factor = 0.0
if self.training and self.track_running_stats:
if self.num_batches_tracked is not None:
self.num_batches_tracked += 1
if self.momentum is None:
exponential_average_factor = 1.0 / float(self.num_batches_tracked)
else:
exponential_average_factor = self.momentum
# calculate running estimates
if self.training:
mean = input.mean([0, 2, 3])
var = input.var([0, 2, 3], unbiased=False)
m = input.numel() / input.size(1)
with torch.no_grad():
self.running_mean = exponential_average_factor * mean\
+ (1 - exponential_average_factor) * self.running_mean
self.running_var = exponential_average_factor * var * m / (m - 1)\
+ (1 - exponential_average_factor) * self.running_var
else:
mean = self.running_mean
var = self.running_var
input = (input - mean[None, :, None, None]) / (torch.sqrt(var[None, :, None, None] + self.eps))
if self.affine:
input = input * self.weight[None, :, None, None] + self.bias[None, :, None, None]
return input
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv = nn.Conv2d(3, 64, kernel_size=3, padding=1)
self.bn = BatchNorm2d(64)
print(" printing bn mean when init")
print(self.bn.running_mean)
print(" printing bn when init")
print(self.bn.running_mean)
self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
self.classifier = nn.Linear(64, 10)
def forward(self, y):
y = self.conv(y)
y = self.bn(y)
y = fun.relu(y)
y = self.pool(y)
y = self.avgpool(y)
y = y.view(y.size(0), -1)
y = self.classifier(y)
print("printing bn running mean from NET during forward")
print(net.module.bn.running_mean)
print("printing bn running mean from SELF. during forward")
print(self.bn.running_mean)
print("printing bn running var from NET during forward")
print(net.module.bn.running_var)
print("printing bn running mean from SELF. during forward")
print(self.bn.running_var)
return y
# Data
print('Preparing data..')
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))])
train_set = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)
train_loader = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True, num_workers=2)
test_set = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)
test_loader = torch.utils.data.DataLoader(test_set, batch_size=64, shuffle=False, num_workers=2)
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
# Model
print('Building model..')
net = Net()
net = torch.nn.DataParallel(net).cuda()
print('Number of GPU {}'.format(torch.cuda.device_count()))
criterion = nn.CrossEntropyLoss()
optimizer = opt.SGD(net.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4)
# Training
def train(epoch):
print('\nEpoch: %d' % epoch)
net.train()
train_loss = 0
correct = 0
total = 0
for batch_idx, (inputs, targets) in enumerate(train_loader):
inputs, targets = inputs.cuda(), targets.cuda()
outputs = net(inputs)
loss = criterion(outputs, targets)
print("printing bn running mean FROM net after forward")
print(net.module.bn.running_mean)
print("printing bn running var FROM net after forward")
print(net.module.bn.running_var)
break
for epoch in range(0, 1):
train(epoch)
输出:
在下面的输出中，我们可以看到屏幕上计算了训练数据的运行平均值。
PyTorch batch normalization running mean
PyTorch 批量标准化评估模式
在本节中，我们将学习 python 中的 PyTorch 批处理规范化评估模式。
PyTorch 批处理规范化被定义为训练神经网络的过程。使用评估模式只是一种开关，作用于训练和评估时间的某些层。
代码:
在下面的代码中，我们将导入一些库，从中我们可以训练网络并评估该网络。
torch.manual_seed(34)用于设置固定的随机种子。- X = torch.rand(200，1，200) 用于生成随机数。
- 打印(batchnormalization。【running _ var)】用于打印批量归一化运行 var。
- print(f ' momentum = { momentum } yields { batch normalization(X))。mean()}for eval mode’)用于打印 eval mode。
import torch
import torch.nn as nn
for momentum in [None, 1]:
torch.manual_seed(34)
batchnormalization = nn.BatchNorm1d(1, momentum=momentum)
X = torch.rand(200,1,200)
print(batchnormalization .running_var)
batchnormalization .train()
print(f'momentum = {momentum} yields {batchnormalization (X).mean()} for train mode')
print(batchnormalization .running_var)
batchnormalization .running_var.data.mul_(1 - 1 / (200*200))
batchnormalization .eval()
print(f'momentum = {momentum} yields {batchnormalization (X).mean()} for eval mode')
输出:
运行上述代码后，我们得到以下输出，可以看到 PyTorch 批处理规范化评估模式数据打印在屏幕上。
PyTorch batch normalization eval mode
因此，在本教程中，我们讨论了 PyTorch 批处理规范化，并且涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch 批处理规范化
- PyTorch 批处理规范化示例
- PyTorch 批处理规范化实现
- PyTorch 批次标准化 1d
- PyTorch 批处理规范化 2d
- PyTorch 批量标准化 3d
- PyTorch 批量标准化 lstm
- PyTorch 批处理规范化 conv2d
- PyTorch 批量标准化运行均值
- PyTorch 批处理规范化评估模式
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch 二元交叉熵
在这个 Python 教程中，我们将学习 Python 中的 PyTorch 二元交叉熵，我们还将涵盖与二元交叉熵相关的不同例子。此外，我们将涵盖这些主题。
- PyTorch 二元交叉熵
- PyTorch 二元交叉熵示例
- 具有对数的 PyTorch 二元交叉熵
- PyTorch 二元交叉熵权
- PyTorch 二元交叉熵损失函数
- PyTorch 二元交叉熵 pos_weight
- PyTorch 二元交叉熵 sigmoid
目录
- PyTorch 二元交叉熵
- PyTorch 二元交叉熵示例
- PyTorch 二元交叉熵与逻辑
- PyTorch 二元交叉熵权
- PyTorch 二元交叉熵损失函数
- PyTorch 二元交叉熵 pos_weight
- PyTorch 双星交叉熵 sigmoid
PyTorch 二元交叉熵
本节我们将学习 python 中的****【py torch】二进制交叉熵。
它创建了一个计算目标概率和输入概率之间的二元交叉熵的规范。
语法:
PyTorch 中二元交叉熵的语法如下:
torch.nn.BCELoss(weight=None,size_average=None,reduce=None,reduction='mean)
参数:
- 权重给每个元素的损失重新计算权重。
size_average损失在批次中的每个损失元素上平均。- 减少损失是每个迷你批次的平均观察值，取决于 size_average。
- 缩减说明应用于输出的缩减:“无”、“平均值”、“总和”。
- ‘无’定义为不应用任何缩减。
- ‘mean’定义为将输出的总和除以输出中的元素数。
- ‘sum’定义为给定输出将被求和。
阅读 PyTorch 型号总结
PyTorch 二元交叉熵示例
在这一节中，我们将借助 PyTorch 中的一个例子来了解如何实现二元交叉熵。
创建范数来计算目标概率和输入概率之间的二元交叉熵。它还用于计算重建误差。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以计算二进制交叉熵。
- x = nn。Sigmoid() 用于保证单元的输出在 0 和 1 之间。
- 损失= nn。BCELoss() 用于计算二元交叉熵损失。
- input_prob = torch.randn(4，requires_grad=True) 用于计算输入概率。
- target_prob = torch.empty(4)。random_(3) 用于计算目标概率。
- output _ prob = loss(x(input _ prob)，target_prob) 用于得到输出概率。
print(output_prob)用于在屏幕上打印输出概率。
import torch
import torch.nn as nn
x = nn.Sigmoid()
loss = nn.BCELoss()
input_prob = torch.randn(4, requires_grad=True)
target_prob = torch.empty(4).random_(3)
output_prob = loss(x(input_prob), target_prob)
output_prob.backward()
print(output_prob)
输出:
运行上面的代码后，我们得到下面的输出，可以看到二进制交叉熵值打印在屏幕上。
PyTorch binary cross entropy example
PyTorch 二元交叉熵与逻辑
在这一节中，我们将学习 python 中带有 logits 的 PyTorch 二元交叉熵。
二元交叉熵将每个预测概率与实际输出(可能是 0 或 1)进行对比。
它还根据与期望值的距离计算处理概率的分数。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以用 logits 计算二进制交叉熵。
- Bceloss = nn。BCEWithLogitsLoss() 用于计算二元交叉熵 logit 损失。
- inp_var = torch.randn(7，requires_grad=True) 作为输入变量。
- tar_var = torch.empty(7)。random_(6) 作为目标变量。
- out_var = Bceloss(inp_var，tar_var) 用于计算输出变量。
print(out_var)用于打印输出变量。
import torch
import torch.nn as nn
Bceloss = nn.BCEWithLogitsLoss()
inp_var = torch.randn(7, requires_grad=True)
tar_var = torch.empty(7).random_(6)
out_var = Bceloss(inp_var, tar_var)
out_var.backward()
print(out_var)
输出:
在下面的输出中，我们可以看到带有 logits 值的 PyTorch 二元交叉熵被打印在屏幕上。
PyTorch binary cross entropy with logits
PyTorch 二元交叉熵权
在本节中，我们将学习 python 中的 PyTorch 二进制交叉熵权。
它创建了度量输入和目标概率之间的二元交叉熵的标准。二元交叉熵中的权重是迭代可调的
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以计算二进制交叉熵权重。
- critrion = nn。BCEWithLogitsLoss(pos _ weight = poswight)用于计算二元交叉熵。
- loss = critrion(a，b) 用于计算损失。
weight = torch . ones _ like(loss rw)用于生成权重。- critrionrw_sig = nn。BCELoss(reduction='none') 用于创建标准原始 s 形线。
- loss rw _ SIG = critrion rw _ SIG(torch . sigmoid(a)，b) 用于计算原始 sigmoid 的损耗。
- print(loss–loss rw)用于在屏幕上打印损耗值。
import torch
import torch.nn as nn
for x in range(70):
poswight = torch.randint(1, 100, (1,)).float()
critrion = nn.BCEWithLogitsLoss(pos_weight=poswight)
a = torch.randn(15, 3, requires_grad=True)
b = torch.randint(0, 4, (15, 3)).float()
loss = critrion(a, b)
critrionrw = nn.BCEWithLogitsLoss(reduction='none')
lossrw = critrionrw(a, b)
weight = torch.ones_like(lossrw)
weight[b==1.] = poswight
lossrw = (lossrw * weight).mean()
critrionrw_sig = nn.BCELoss(reduction='none')
lossrw_sig = critrionrw_sig(torch.sigmoid(a), b)
lossrw_sig = ((lossrw_sig) * weight).mean()
print(loss - lossrw)
print(lossrw_sig - loss)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 二进制交叉熵权值被打印在屏幕上。
PyTorch binary cross entropy weight
阅读: PyTorch 批量标准化
PyTorch 二元交叉熵损失函数
在本节中，我们将学习 python 中的 PyTorch 交叉熵损失函数。
二进制交叉熵是一个损失函数，它将每个预测概率与实际输出进行比较，实际输出可以是 0 或 1。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以计算二进制交叉熵损失函数。
- ypredic = num.array([0.1582，0.4139，0.2287]) 用于预测 y 值。
- TTL BCE _ loss = num . sum(-y true * num . log(ypredic)–( 1–y true) num . log(1–ypredic))*用于计算总的二元交叉熵损失值。
- numb of _ sampls = ypredic . shape[0]用于获取样本数。
mean BCE _ loss = TTL BCE _ loss/numb of _ sampls用于计算平均值。- print(" BCE error is:"+str(BC eval))用于打印二进制交叉熵误差。
import torch
import torch.nn as nn
import numpy as num
ypredic = num.array([0.1582, 0.4139, 0.2287])
ytrue = num.array([0.0, 0.0, 1.0])
def BCE(ypredic, ytrue):
ttlbce_loss = num.sum(-ytrue * num.log(ypredic) - (1 - ytrue) * num.log(1 - ypredic))
# Getting the mean BCE loss
numbof_sampls = ypredic.shape[0]
meanbce_loss = ttlbce_loss / numbof_sampls
return meanbce_loss
bceval = BCE(ypredic, ytrue)
print ("BCE error is: " + str(bceval))
输出:
运行上面的代码后，我们得到下面的输出，可以看到二进制交叉熵损失值打印在屏幕上。
PyTorch binary cross entropy loss function
阅读: PyTorch 负载模型+示例
PyTorch 二元交叉熵 pos_weight
在本节中，我们将学习 python 中的 PyTorch 交叉熵 pos_weight 。
pos_weight 被定义为正例的权重。它必须是一个向量，长度等于几个类。
代码:
在下面的代码中，我们将导入一些模块，从中我们可以计算正例的权重。
- tar_var = torch.ones([15，69]，dtype=torch.float32) 用于计算批量为 15 和 69 类的目标值。
- out_var = torch.full([15，69]，2.0) 用作预测 logit。
- pos weight = torch . ones([69])作为正例的权重，所有权重等于 1。
- critrion(out_var，tar_var) 用于创建度量二进制交叉熵的标准。
import torch
import torch.nn as nn
tar_var = torch.ones([15, 69], dtype=torch.float32)
out_var = torch.full([15, 69], 2.0)
posweight = torch.ones([69])
critrion = torch.nn.BCEWithLogitsLoss(pos_weight=posweight)
critrion(out_var, tar_var)
输出:
在下面的输出中，我们可以看到所有权重都等于 1 的 PyTorch 交叉熵 pos_weight 值被打印在屏幕上。
PyTorch binary cross entropy pos_weight
阅读: PyTorch nn 线性+例题
PyTorch 双星交叉熵 sigmoid
在本节中，我们将学习 python 中的 PyTorch 二元交叉熵 sigmoid 。
sigmoid 函数是一个实函数，它定义了所有的输入值，并且在每个点都有一个非负导数。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以计算二进制交叉熵 sigmoid。
- inp_var = torch.randn(5，4，requires_grad=True) 用于生成输入变量。
- tar_var = torch.rand(5，4，requires_grad=False) 用于生成目标变量。
- loss = fun . binary _ cross _ entropy(torch . sigmoid(InP _ var)，tar_var) 用于计算二元交叉熵 sigmoid 函数。
print(loss)用于在屏幕上打印损耗值。
import torch
from torch.nn import functional as fun
inp_var = torch.randn(5, 4, requires_grad=True)
tar_var = torch.rand(5, 4, requires_grad=False)
loss = fun.binary_cross_entropy(torch.sigmoid(inp_var), tar_var)
loss.backward()
print(loss)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 二进制交叉熵 sigmoid 值打印在屏幕上。
PyTorch binary cross entropy sigmoid
您可能也喜欢阅读以下 Python 教程。
因此，在本教程中，我们讨论了 PyTorch 二进制交叉熵，我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch 二元交叉熵
- PyTorch 二元交叉熵示例
- 具有对数的 PyTorch 二元交叉熵
- PyTorch 二元交叉熵权
- PyTorch 二元交叉熵损失函数
- PyTorch 二元交叉熵 pos_weight
- PyTorch 二元交叉熵 sigmoid
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何使用 PyTorch 猫功能
PyTorch cat 函数用于连接给定维度中给定顺序的序列张量。详细来说，我们将讨论在 Python 中使用 PyTorch 的 cat 函数。
此外，我们将介绍与 PyTorch Cat 函数相关的不同示例。我们将讨论这些话题。
- PyTorch 猫功能是什么
- PyTorch cat 函数示例
- 如何使用维数为-1 的 PyTorch cat 函数
- 使用尺寸为 0 的 PyTorch cat 函数
- 如何使用 PyTorch 3D 张量沿 0 和-1 维连接(cat)
- PyTorch 猫 vs 栈
目录
- PyTorch 猫功能
- PyTorch 猫函数示例
- 如何使用尺寸为-1 的 PyTorch cat 功能
- PyTorch cat 功能使用尺寸为 0
- 如何使用 PyTorch 3D 张量沿 0 和-1 维连接(cat)
- PyTorch 猫 vs 栈
PyTorch 猫功能
在这一节中，我们将学习 python 中的 Pytorch cat 函数。
PyTorch cat 函数用于连接给定维度中给定顺序的序列张量，并且这些张量必须具有相同的形状。
语法:
PyTorch cat 函数的语法:
torch.cat(tensors, dim=0, out=None)
参数:
以下是 PyTorch cat 函数的参数:
- 张量:张量是任何 python 序列的同类型张量的参数，所提供的非空张量必须具有相同的形状，除了在 cat 维中。
- dim = 0:dim 用作一个维度，张量在其上连接。
- out = None:out 定义为输出张量，out 的默认值为 None。
这样，我们通过使用一个 torch.cat() 函数来理解 Pytorch cat 函数。
PyTorch 猫函数示例
在本节中，我们将学习如何借助 python 中的一个例子来实现 PyTorch cat 函数。
torch.cat()函数用于沿现有轴连接两个或多个张量。
代码:
在下面的代码中，我们将导入所需的库，如 import torch。
- c = torch.randn(4，6): 这里我们使用 torch.randn()函数声明变量。
- a=torch.cat((c，c，c)，0): 这里我们调用的是 torch.cat()函数。
print(a)用于通过 print()函数打印变量 a。
# Import the torch library
import torch
# Declaring the variable
c = torch.randn(4, 6)
print(c)
# Calling the cat() function
a=torch.cat((c, c, c), 0)
b=torch.cat((c, c, c), 1)
# Print the output
print(a)
print(b)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch cat 值被打印在屏幕上。
PyTorch cat function example
至此，我们通过一个例子了解了如何实现 Pytorch cat 函数。
如何使用尺寸为-1 的 PyTorch cat 功能
在本节中，我们将学习 python 中使用 dimension as -1 的 PyTorch cat 函数。
这里我们使用 torch.cat()函数，该函数通过使用 dim as -1 将两个或多个张量按行连接起来。
代码:
在下面的代码中，我们将导入必要的库，如 import torch。
- cattens1 =火炬。张量([[12，13，14]，[15，16，17]]): 这里我们用 torch.tensor()函数声明 cattensor 变量。
- print("Cattensor1 \n "，cattens1): 这里我们使用 print()函数打印第一个张量。
- cattensor = torch.cat((cattens 1，cattens2)，-1): 这里我们调用的是 torch . cat()函数。
- print(" Concatenate the tensor in-1 dimension \ n "，cattensor): 这里我们打印的是-1 维的连接张量。
# import torch library
import torch
# Declaring the tensors
cattens1 = torch.Tensor([[12, 13, 14], [15, 16, 17]])
cattens2 = torch.Tensor([[18,19, 20], [21, 22, 23]])
# print first tensors
print("Cattensor1 \n", cattens1)
# print second tensor
print("Cattensor2 \n", cattens2)
# Calling the torch.cat() function and join tensor in -1 dimension
cattensor = torch.cat((cattens1, cattens2), -1)
print("Concatenate the tensors in the -1 dimension \n", cattensor)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到使用 dimension as -1 值的 PyTorch cat 函数被打印在屏幕上。
PyTorch cat function using dimension as -1
这样，我们理解了 PyTorch cat 函数使用 dimension as -1。
阅读: PyTorch 查看教程
PyTorch cat 功能使用尺寸为 0
在本节中，我们将学习 python 中使用 dimension as 0 的 PyTorch cat 函数。
这里我们使用 torch.cat()函数，该函数通过将 dimension 设为 0 来连接两个或多个列方向的张量。
代码:
在下面的代码中，我们将导入所需的库，如 import torch。
- c1 = torch.tensor([2，4，6，8]): 这里我们用 torch.tensor()函数声明变量。
- print("cat1:\n "，c1) 用来打印上面我们要借助 print()函数创建的张量。
- c=torch.cat((c1，c2，c3，c4)，dim=0 ): 这里我们调用 torch.cat()函数来连接张量。
print(c)用于通过 print()函数打印输出。
# Import library
import torch
# Declaring the variable
c1 = torch.tensor([2,4,6,8])
c2 = torch.tensor([3,6,9,12])
c3 = torch.tensor([4,8,12,16])
c4 = torch.tensor([5,10,15,20])
# Print the above created tensors
print("cat1:\n", c1)
print("cat2:\n", c2)
print("cat3:\n", c3)
print("cat4:\n", c4)
# Calling the torch.cat() function
c=torch.cat(
(c1,c2,c3,c4)
,dim=0
)
# Print the output
print(c)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到使用 dimension 作为 0 值的 PyTorch cat 函数被打印在屏幕上。
PyTorch cat function using dimension as 0
这就是我们如何理解使用 dimension 作为 0 的 PyTorch cat 函数。
如何使用 PyTorch 3D 张量沿 0 和-1 维连接(cat)
在这一节中，我们将学习 P yTorch 3d 张量，并在 python 中沿着 0 和-1 维连接。
这里我们使用 torch.cat()函数，它通过使用 0 和-1 维来连接两个或多个列方向和行方向的张量。
代码:
在下面的代码中，我们将导入必要的库，如 import torch。
- c1 =火炬。张量([[2，4]，[3，6]]) 用于通过使用 torch.tensor()函数创建张量。
- print("cat1:\n "，c1) 用于打印我们使用 print()函数创建的上述张量。
- c = torch.cat((c1，c2，c3)，0):这里我们调用的是 torch.cat()函数以及 0 维。
- print(" Concatenate the tensors in the 0 dimension ")用于打印 0 维中的连接张量。
- c = torch.cat((c1，c2，c3)，-1): 这里我们调用的是 torch.cat()函数连同-1 维。
# import required library
import torch
# create the tensors
c1 = torch.Tensor([[2,4],[3,6]])
c2 = torch.Tensor([[4,8],[5,10]])
c3 = torch.Tensor([[6,12],[7,14]])
# print above created tensors
print("cat1:\n", c1)
print("cat2:\n", c2)
print("cat3:\n", c3)
# Print the tensor in the 0 dimension
print("Concatenate the tensors in the 0 dimension")
# Calling the torch.cat() function
c = torch.cat((c1,c2,c3), 0)
print("c:\n", c)
print("Concatenate the tensors in the -1 dimension")
c = torch.cat((c1,c2,c3), -1)
print("c:\n", c)
输出:
在下面的输出中，我们可以看到 PyTorch 3d 张量沿着屏幕上打印的 0 和-1 维值连接在一起。
PyTorch 3D tensor are concatenate(cat) along 0 and -1 dimension
这样，我们理解了 PyTorch 3D 张量是如何沿着 0 维和-1 维连接(cat)的。
阅读: PyTorch 整形张量
PyTorch 猫 vs 栈
在本节中，我们将学习 python 中的 PyTorch cat vs stack 。
猫():
torch.cat() 函数用于连接给定维度中给定顺序的序列张量，并且这些张量必须具有相同的形状。
代码:
在下面的代码中，我们将导入所需的库，如 import torch。
- c1 = torch.tensor([2，4，6，8]): 这里我们用 torch.tensor()函数来声明张量。
- c=torch.cat((c1，c2，c3，c4)，dim=0 ): 这里我们调用的是 cat()函数。
print(c)用于使用print()功能打印输出。
# Import torch
import torch
# Declaring the tensors
c1 = torch.tensor([2,4,6,8])
c2 = torch.tensor([3,6,9,12])
c3 = torch.tensor([4,8,12,16])
c4 = torch.tensor([5,10,15,20])
print(c1,c2,c3,c4)
# Calling the cat() function
c=torch.cat(
(c1,c2,c3,c4)
,dim=0
)
# Print the output
print(c)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch cat 值被打印在屏幕上。
PyTorch cat
Stack():
py torch*torch . stack()*函数用于连接具有相同维度和形状的张量。
代码:
在下面的代码中，我们将导入所需的库，如 import torch。
- s1 = torch.tensor([2，4，6，8]) 用于通过使用 torch.tensor()函数来声明张量。
- s=torch.stack((s1，s2，s3，s4)，dim=0 ): 这里我们调用的是 torch.stack()函数。
# Import torch
import torch
# Declaring the tensors
s1 = torch.tensor([2,4,6,8])
s2 = torch.tensor([3,6,9,12])
s3 = torch.tensor([4,8,12,16])
s4 = torch.tensor([5,10,15,20])
# Calling stack() function
s=torch.stack(
(s1,s2,s3,s4)
,dim=0
)
# Print the output
print(s)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch stack()值被打印在屏幕上。
PyTorch stack
这就是我们如何理解 cat()和 stack()函数之间的区别。
您可能也喜欢阅读以下 Python 版本的 PyTorch 教程。
因此，在本教程中，我们讨论了 PyTorch cat 函数，我们还介绍了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch 猫功能是什么？
- PyTorch cat 函数示例
- 如何使用维数为-1 的 PyTorch cat 函数
- 使用尺寸为 0 的 PyTorch cat 函数
- 如何使用 PyTorch 3D 张量沿 0 和-1 维连接(cat)
- PyTorch 猫 vs 栈
我是一名机器学习工程师，目前作为一名 Python 开发人员在 Tsinfo Technologies 工作。我有使用各种 Python 库的经验，比如 Scikit learn、Turtle、PyTorch 等。
PyTorch Conv1d【附 12 个惊人例子】
PyTorch conv1d 定义为一维卷积，应用于从一些输入层收集的输入信号。详细来说，我们将讨论在 python 中使用 PyTorch 的 Conv1d。此外，我们还将介绍与 PyTorch Conv1d 相关的不同示例。我们将讨论这些话题。
- PyTorch Conv1d
- PyTorch Conv1d 示例
- PyTorch 功能转换器 1d
- PyTorch Conv1d 衬垫
- PyTorch Conv1d 集团
- PyTorch Conv1d 延时
- CNN 的 PyTorch Conv1d
- PyTorch Conv1d 重量
- PyTorch Conv1d 转置
- PyTorch Conv1d 参数
- PyTorch Conv1d 偏置
- PyTorch Conv1d 输入通道和输出通道
目录
- PyTorch Conv1d
- PyTorch Conv1d 示例
- PyTorch 功能转换器 1d
- PyTorch Conv1d 填充
- PyTorch Conv1d 组
- PyTorch Conv1d 稀释
- 美国有线电视新闻网
- PyTorch Conv1d 权重
- PyTorch Conv1d 应答
- PyTorch Conv1d 参数
- PyTorch Conv1d 偏置
- PyTorch Conv1d 输入通道和输出通道
PyTorch Conv1d
在本节中，我们将学习 python 中的 PyTorch Conv1d 。
PyTorch conv1d 定义为一维卷积，应用于从一些输入平面收集的输入信号。
语法:
PyTorch Conv1d 的语法是:
torch.nn.Conv1d(in_channels, out_channels, Kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', device=None, dtype=None)
参数:
以下是 PyTorch Conv1d 的参数:
in_channels用作输入图像中的通道数。out_channels用作卷积产生的通道数。Kernel_size用于定义卷积核的大小。- 步距用于控制互相关和单个数字或一元元组的步距。
- 填充用于控制应用于输入的填充量。它可以是字符串，也可以是给定隐式填充量的元组。填充的默认值为 0。
- 膨胀用于控制内核元素之间的间距，膨胀的默认值为 1。
- 组用于控制输入和输出之间的连接。组的默认值为 1。
- 偏差:偏差的默认值为真。如果这是真的，它会给输出增加一个可学习的偏差。如果为假，则不会给输出增加任何可学习的偏差。
由此，我们理解了 PyTorch Conv1d。
PyTorch Conv1d 示例
在本节中，我们将借助一个例子来学习如何实现 PyTorch Conv1d 。
PyTorch Conv1d 用于生成卷积核，该卷积核与单一概念维度上的层输入一起扭曲，从而形成输出张量。
代码:
在下面的代码中，首先我们将导入所有必要的库，如导入火炬，导入火炬。nn 为 nn。
- c = nn。Conv1d(18，35，5，stride=2) 这里我们用的是 nn。Conv1d()函数。
- input = torch.randn(22，18，52) 用于通过 torch.randn()函数声明变量。
output = c(input)用于描述输出变量。- 打印(输出)用于使用 print()函数打印输出。
# Import Library
import torch
import torch.nn as nn
# Using nn.Conv1d() function
c = nn.Conv1d(18, 35, 5, stride=2)
# Declaring a input variable
input = torch.randn(22, 18, 52)
output = c(input)
# Print output
print(output)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch Conv1d 值被打印在屏幕上。
PyTorch Conv1d example
所以，有了这个，我们借助一个例子理解了 PyTorch Conv1d。
阅读: PyTorch nn 线性+例题
PyTorch 功能转换器 1d
在本节中，我们将学习 python 中的 PyTorch 函数 Conv1d 。
PyTorch 函数 Conv1d 对从一些输入层收集的输入信号进行一维卷积运算。
语法:
PyTorch 函数 Conv1d 的语法是:
torch.nn.functional.conv1d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1)
参数:
以下是 PyTorch 功能 Conv1d 的参数:
- 输入:输入定义为形状的输入张量(minibatch，in_channels，iW)。
- 权重:权重定义为形状的过滤器(out_channels)。
- 偏差:偏差定义为形状的可选偏差张量(out_channels)。偏差的默认值是无。
- 步幅:卷积核的步幅。stride 的默认值为 1。
- 填充:用于控制应用于输入的填充量。它可以是字符串，也可以是给定隐式填充量的元组。填充的默认值为 0。
- 膨胀:用于控制内核元素之间的间距，膨胀的默认值为 1。
- 组用于控制输入和输出之间的连接。组的默认值为 1。
由此，我们理解了 PyTorch 泛函 Conv1d。
阅读: PyTorch 批量标准化
PyTorch Conv1d 填充
在本节中，我们将学习 python 中的 PyTorch Conv1d 填充符。
PyTorch Conv1d 填充定义为一个参数，用于控制应用于输入的填充量。它可以是字符串，也可以是给定隐式填充量的元组。填充的默认值为 0。
代码:
在下面的代码中，首先我们将导入火炬库作为导入火炬。
- inputs = torch.rand([42，42，105]): 这里我们用 torch.rand()函数来描述输入变量。
- n = torch.nn.Conv1d(42，12，kernel_size=3，stride=2，padding=3): 这里我们用方形核和带 padding 的等步幅来描述一个变量。
- 打印(输出)用于借助 print()函数打印输出。
# Import library
import torch
# Describe a variable
inputs = torch.rand([42, 42, 105])
# Describe a variable by using square kernels and equal stride with padding
n = torch.nn.Conv1d(42, 12, kernel_size=3, stride=2, padding=3)
output= n(inputs)
# Print the output
print(output)
print(output.shape)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch Conv1d 填充值打印在屏幕上。
PyTorch Conv1d padding
此外，检查: Keras 与 py torch–主要差异
PyTorch Conv1d 组
在本节中，我们将学习 python 中的 PyTorch Conv1d 组。
PyTorch Conv1d 组被定义为用于控制输入和输出之间连接的参数。组的默认值为 1。
代码:
在下面的代码中，首先我们将导入火炬库作为导入火炬。
- inputs = torch.rand([42，42，102]: 这里我们用 torch.rand()函数来描述输入变量。
- x = torch.nn.Conv1d(42，12，kernel_size=3，stride=2): 这里我们用方形核和带填充的等步幅来描述一个变量。
- 打印(输出)用于借助 print()函数打印输出。
# Import library
import torch
# Describe a variable
inputs = torch.rand([42, 42, 102])
# Describing a variable by using square kernels and equal stride
x = torch.nn.Conv1d(42, 12, kernel_size=3, stride=2)
output = x(inputs)
# Print the output
print(output)
输出:
在下面的输出中，您可以看到 PyTorch Conv1d 值打印在屏幕上。
PyTorch conv1d group
这样，我们就了解了 PyTorch Conv1d 组。
阅读: PyTorch 负载模型+示例
PyTorch Conv1d 稀释
在本节中，我们将学习 python 中的 PyTorch Conv1d 膨胀。
PyTorch Conv1d 膨胀被定义为用于控制内核元素之间的间距的参数，并且膨胀的默认值是 1。
代码:
在下面的代码中，首先我们将导入火炬库，比如导入火炬。
- inputs = torch.rand([42，42，102]): 这里我们用 torch.rand()函数来描述输入变量。
- x = torch.nn.Conv1d(42，12，kernel_size=3，stride=2) :这里我们用正方形核和带填充的等步幅来描述一个变量。
- 打印(输出)用于借助 print()函数打印输出。
# Import library
import torch
# Describe a variable
inputs = torch.rand([42, 42, 102])
# Describing a variable by using square kernels and equal stride
x = torch.nn.Conv1d(42, 12, kernel_size=3, stride=2)
output = x(inputs)
# Print the output
print(output)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch Conv1d 膨胀值打印在屏幕上。
PyTorch Conv1d dilation
由此，我们理解了 PyTorch 膨胀。
阅读: PyTorch 全连接层
美国有线电视新闻网
在这一节中，我们将了解 CNN 的 PyTorch Conv1d。
在继续之前，我们应该有一些关于 CNN(卷积神经网络)的知识。
卷积神经网络是一种用于图像识别的人工神经网络。
这里我们用 Conv1d 来处理一个卷积神经网络。Conv1d()函数在输入上应用 1d 卷积。Conv1d 等待输入为(batch_size 和 input_channels)等的形状。
代码:
在下面的代码中，首先我们将导入所有必要的库，如 import numpy as np，import torch，import torch.nn as nn，import torch.optim as optim，以及从 torch.utils.data 导入 Dataset，Dataloader。
- inp1 = torch.tensor([2，4，6，8，10，12，14，16，18，20]，dtype = torch.float): 这里我们用 torch.tensor()函数定义输入张量。
- inp1 = inp1.unsqueeze(0)。unsqueeze(0) 用于将输入转换为张量。
- cnnconv = nn。Conv1d(in_channels=1，out_channels=1，kernel_size=3，stride=1) 用于对输入应用 Conv1d。
- print("cnn1d: \n") 用于通过 print()函数打印 CNN conv1d。
# Import Library
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
# Define Input tensor
inp1 = torch.tensor([2, 4, 6, 8, 10, 12, 14, 16, 18, 20], dtype = torch.float)
inp2 = torch.tensor([[2, 4, 6, 8, 10], [12, 14, 16, 18, 20]], dtype = torch.float)
inp2img = torch.tensor([[[2, 4, 6, 8, 10, 12, 14, 18, 20, 24], [2, 4, 6, 8, 10, 12, 14, 16, 18, 20], [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]], [[2, 4, 6, 8, 10, 12, 14, 16, 18, 20], [2, 4, 6, 8, 10, 12, 14, 16, 18, 20], [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]], [[2, 4, 6, 8, 10, 12, 14, 16, 18, 20], [2, 4, 6, 8, 10, 12, 14, 16, 18, 20], [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]]], dtype = torch.float)
# Convert the input into tensor
inp1 = inp1.unsqueeze(0).unsqueeze(0)
inp1.shape
# Applies 1d convolution over the input
cnnconv = nn.Conv1d(in_channels=1, out_channels=1, kernel_size=3, stride=1)
print("cnn1d: \n")
print(cnnconv(inp1).shape, "\n")
print(cnnconv(inp1))
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 CNN 值中的 PyTorch Conv1d 被打印在屏幕上。
PyTorch Conv1d in CNN
所以，有了这个，我们理解了 CNN 的 PyTorch Conv1d。
阅读: PyTorch 双星交叉熵
PyTorch Conv1d 权重
在本节中，我们将学习 python 中的 PyTorch Conv1d weigh t。
PyTorch Conv1d 权重用于对 1d 数据和一些附加选项(如填充)执行卷积。
代码:
在下面的代码中，首先我们使用 torch 模块，比如 import torch。
- inp = torch.ones(1，1，6): 这里我们用
torch.ones()函数来描述输入变量。 - print("Input = "，inp) 用于借助 print()函数打印输入。
- m = torch.nn.Conv1d(in _ channels = 1，out_channels = 1，kernel_size = 3): 这里我们通过使用 torch . nn . conv1d()函数来使用变量。
- print("Parameters = "，list(m.parameters())) 用于打印参数表。
- print("Weight = "，m.weight) 用于打印重量。
- print("Output = "，out) 用于通过 print()函数打印输出。
# Import library
import torch
# Describe the input variable
inp = torch.ones(1,1,6)
# Print input
print("Input = ",inp)
m = torch.nn.Conv1d(in_channels = 1, out_channels = 1, kernel_size = 3)
# Print the parameter list
print("net = ",m)
print("Parameters = ",list(m.parameters()))
# Print the weight
print("Weight = ",m.weight)
out = m(inp)
print("Output = ",out)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch Conv1d 权重值被打印在屏幕上。
PyTorch Conv1d weight
这就是我们如何使用 PyTorch Conv1d 砝码。
阅读: PyTorch 数据加载器+示例
PyTorch Conv1d 应答
在本节中，我们将学习 python 中的 PyTorch Conv1d 转置。
PyTorch Convtranspose1d 对从一些输入平面收集的输入图像应用 1d 转置卷积运算。
语法:
PyTorch Conv1d 转置的语法:
torch.nn.ConvTranspose1d(in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True, dilation=1, padding_mode='zeros', device=None, dtype=None)
参数:
以下是 PyTorch Conv1d 移调的参数
in_channels用作输入图像中的几个通道。- out_channels 用作卷积产生的几个通道。
kernel_size用作卷积核的大小。- 步距用于控制来自互相关的步距。
- 填充:控制隐式补零的数量。
- output_padding: 控制添加到输出形状一侧的附加尺寸。
- 膨胀:控制内核点之间的间距。
- 组:控制输入和输出之间的连接。
这样，我们理解了 PyTorch Conv1d 转座。
阅读: PyTorch 提前停止+示例
PyTorch Conv1d 参数
在本节中，我们将学习 python 中的 PyTorch Conv1d 参数。
在继续之前，我们应该了解一些关于参数的知识。参数是可测量的因素，被认为是描述系统或设定其运行条件的集合之一。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch，import torch.nn as nn。
- c = nn。Conv1d(20，37，5，stride=2): 这里我们用 nn 来描述变量。具有正方形核和等步长的 Conv1d()函数。
- inp = torch.randn(24，20，54): 这里我们用 torch.randn()函数来描述输入变量。
out = c(inp)用于描述输出变量。print(out)用于使用 print()函数打印输出。
# Importing Libraries
import torch
import torch. nn as nn
# Describing the variable by using nn.Conv1d() function with square kernels and equal stride
c = nn.Conv1d(20, 37, 5, stride=2)
# Describe the variable
inp = torch.randn(24, 20, 54)
# Declare the output variable
out = c(inp)
# Print output
print(out)
输出:
在下面的输出中，您可以看到 PyTorch Conv1d 参数值打印在屏幕上。
PyTorch Conv1d parameters
至此，我们了解了 PyTorch Conv1d 参数。
PyTorch Conv1d 偏置
在本节中，我们将学习 python 中的 PyTorch Conv1d bias 。
PyTorch Conv1d 偏差被定义为形状的可选偏差张量，偏差的默认值为无。
代码:
在下面的代码中，首先我们将导入 torch 库，如 import torch。
- input = torch.ones(2，2，7): 这里我们用 torch.ones()函数来描述输入变量。
- m = torch.nn.Conv1d(in _ channels = 1，out_channels = 1，kernel_size = 3): 这里我们使用的是 torch . nn . conv1d()函数。
- print("Parameters = "，list(m.parameters())) 用于打印参数列表。
- print("bias = "，m.bias) 用于借助 print()函数打印偏差。
# Import library
import torch
# Describe the input variable
input = torch.ones(2,2,7)
print("Input = ",input)
# Using conv1d module
m = torch.nn.Conv1d(in_channels = 1, out_channels = 1, kernel_size = 3)
# Print the list of the parametrs
print("Net = ",m)
print("Parameters = ",list(m.parameters()))
# Print the bias
print("bias = ",m.bias)
输出:
运行上述代码后，我们得到以下输出，可以看到 PyTorch Conv1d 偏置值打印在屏幕上。
PyTorch Conv1d bias
由此，我们理解了 PyTorch Conv1d 偏差。
阅读: PyTorch 添加尺寸
PyTorch Conv1d 输入通道和输出通道
在本节中，我们将学习 python 中的 PyTorch Conv1d 输入通道和输出通道。
PyTorch Conv1d 输入通道用作输入图像中的通道数。
PyTorch Conv1d 输出通道用作卷积产生的通道数。
代码:
在下面的代码中，首先我们将导入所有必要的库，如 import torch、import Variable from torch . autograded 和 import torch.nn.functional。
- 班级模型(nn。Module): 这里我们使用 init()和 forward()方法创建一个模型类。
- def numflat_featurs(self，y): 这里我们定义了 numflat_features。
- model = model(): 这里我们正在初始化模型。
print(model)用于通过 print()函数打印模型。
# Importing Libraries
import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as fun
# Create model class
class model(nn.Module):
def __init__(self):
super(model, self).__init__()
# 1 input image channel, 8 output channels, 7x7 square convolution
self.conv1 = nn.Conv1d(1, 8, 7)
self.conv2 = nn.Conv1d(8, 18, 7)
# an affine operation: y = Wx + b
self.fc1 = nn.Linear(18 * 7 * 7, 140)
self.fc2 = nn.Linear(140, 86)
self.fc3 = nn.Linear(86, 12)
def forward(self, y):
# Max pooling over a (2, 2) win
y = fun.max_pool2d(fun.relu(self.conv1(y)), (2, 2))
y = fun.max_pool2d(fun.relu(self.conv2(y)), 2)
y = y.view(-1, self.numflat_featurs(y))
y = fun.relu(self.fc1(y))
y = fun.relu(self.fc2(y))
y = self.fc3(y)
return y
def numflat_featurs(self, y):
# all dimensions except the batch dimension
size = y.size()[1:]
numfeaturs = 1
for i in size:
numfeaturs *= i
return numfeaturs
# Instantiate the model
model = model()
# Print the model
print(model)
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到 PyTorch Conv1d 输入通道和输出通道打印在屏幕上。
PyTorch Conv1d input channels and output channels
至此，我们了解了 PyTorch Conv1d 输入通道和输出通道。
另外，再看看一些 PyTorch 教程。
因此，在本教程中，我们讨论了 PyTorch Conv1d ，并且我们还讨论了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch Conv1d
- PyTorch Conv1d 示例
- PyTorch 功能转换器 1d
- PyTorch Conv1d 衬垫
- PyTorch Conv1d 集团
- PyTorch Conv1d 延时
- CNN 的 PyTorch Conv1d
- PyTorch Conv1d 重量
- PyTorch Conv1d 转置
- PyTorch Conv1d 参数
- PyTorch Conv1d 偏置
- PyTorch Conv1d 输入通道和输出通道
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
py torch conv 3d–详细指南
PyTorch Conv3d 是一个在一些输入平面收集的输入信号上应用三维卷积的类。详细来说，我们将使用 python 中的 PyTorch 来讨论 Conv3d。此外，我们还将介绍与 PyTorch Conv3d 相关的不同示例。
- 什么是 PyTorch Conv3d
- PyTorch Conv3d 示例
- PyTorch 泛函 Conv3d
- PyTorch Conv3d 填充
- PyTorch Conv3d 集团
- PyTorch conv3d 扩展
- PyTorch Conv3d 偏置
- CNN 的 PyTorch Conv3d
- PyTorch Conv3d 转置
- PyTorch Conv3d 参数
- PyTorch Conv3d 权值
- PyTorch Conv3d 输入通道和输出通道
目录
- 什么是 PyTorch Conv3d
- PyTorch Conv3d 示例
- PyTorch functional Conv3d
- PyTorch Conv3d 填充
- PyTorch Conv3d 组
- PyTorch conv3d 扩张
- PyTorch Conv3d 偏置
- 美国有线电视新闻网 py torch Conv3d
- PyTorch Conv3d 转译
- PyTorch Conv3d 参数
- PyTorch Conv3d weight
- PyTorch Conv3d 输入 _ 通道和输出 _ 通道
什么是 PyTorch Conv3d
在本节中，我们将学习 python 中的 PyTorch Conv3d 。
PyTorch Conv3d 定义为一种三维卷积，应用于从一些输入平面收集的输入信号。
语法:
PyTorch Conv3d 的语法是:
torch.nn.Conv3d(in_channels, out_channels, Kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', devices=None, dtype=None)
参数:
以下是 PyTorch Conv3d 的参数:
in_channels用作输入图像中的通道数。out_channels用作卷积产生的通道数。Kernel_size用于定义卷积核的大小。- 步距用于控制互相关和单个数字或一元元组的步距。
- 填充用于控制应用于输入的填充量。它可以是字符串，也可以是隐式填充量的元组。填充的默认值为 0。
- 膨胀用于控制内核元素之间的间距，膨胀的默认值为 1。
- 组用于控制输入和输出之间的连接。组的默认值为 1。
- 偏差:偏差的默认值为真。如果这是真的，它会给输出增加一个可学习的偏差。如果为假，则不会给输出增加任何可学习的偏差。
至此，我们了解了 PyTorch Conv3d 的确切含义，在下一节中，我们将展示一个与之相关的示例。
阅读: PyTorch 提前停止+示例
PyTorch Conv3d 示例
在本节中，我们将借助 python 中的示例学习如何实现 PyTorch Conv3d。
PyTorch Conv3d 是一个简单的算术运算，我们在三维数据上滑动一个权重矩阵或内核，并执行数据的元素乘法。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch，import torch.nn as nn。
- c = nn。Conv3d(18，35，5，stride=2): 这里我们通过使用平方核和等跨距来声明变量。
- input = torch.randn(22，18，12，52，102) 用于通过 torch.randn()函数描述输入变量。
print(output)用于使用 print()函数打印输出 bu。
# Importing libraries
import torch
import torch.nn as nn
# Declaring the variable by using square kernels and equal stride
c = nn.Conv3d(18, 35, 5, stride=2)
# Describing the input and output variables
input = torch.randn(22, 18, 12, 52, 102)
output = c(input)
# Print output
print(output)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch Conv3d 值被打印在屏幕上。
PyTorch Conv3d example
这就是我们借助一个例子来理解 PyTorch Conv3d 的方法。
PyTorch functional Conv3d
在本节中，我们将学习 python 中的 PyTorch 函数 Conv3d 。
PyTorch 函数 Conv3d 对从一些输入平面收集的输入图像应用三维卷积。
语法:
PyTorch 函数 Conv3d 的语法是:
torch.nn.functional.conv3d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1)
参数:
以下是 PyTorch 函数 conv3d 的参数:
- 输入:输入定义为形状的输入张量(minibatch，in_channels)。
- 权重:权重定义为形状的过滤器(out_channels)。
- 偏差:偏差定义为形状的可选偏差张量(out_channels)。偏差的默认值是无。
- 步距:卷积核的步距。stride 的默认值为 1。
- 填充用于控制应用于输入的填充量。它可以是字符串，也可以是隐式填充量的元组。填充的默认值为 0。
- 膨胀用于控制内核元素之间的间距，膨胀的默认值为 1。
- 组用于控制输入和输出之间的连接。组的默认值为 1。
举例:
在下面的代码中，首先我们将导入所有必要的库，如 import torch，import torch . nn . functional as function。
- filter = torch.randn(35，18，5，5，5): 这里我们用 torch.randn()函数来描述变量。
- f=function.conv3d(input，filter) 用于描述 function.conv3d()函数。
print(f)用于通过 print()函数打印输出。
# Importing Libraries
import torch
import torch.nn.functional as function
# Describing the variable by using torch.randn() function
filter = torch.randn(35, 18, 5, 5, 5)
input = torch.randn(22, 18, 52, 12, 22)
# Using conv3d() function
f=function.conv3d(input, filter)
# print output
print(f)
输出:
运行上面的代码后，我们得到下面的输出，可以看到 PyTorch 函数 Conv3d 值打印在屏幕上。
PyTorch functional Conv3d
至此，我们了解了 PyTorch 泛函 Conv3d。
阅读: PyTorch 批量标准化
PyTorch Conv3d 填充
在本节中，我们将学习 python 中的 PyTorch Conv3d 填充。
PyTorch Cpnv3d 填充用于控制应用于输入的填充量。它可以是字符串，也可以是给定隐式填充量的元组。填充的默认值为 0。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch，import torch.nn as nn。
- c = nn。Conv3d(18，35，5，stride=2): 这里我们通过使用平方核和等跨距来声明变量。
- p = nn。Conv3d(18，35，(5，7，4)，stride=(4，3，3)，padding=(6，4，0)): 这里我们通过使用非方形内核和带 padding 的不相等步幅来声明变量。
- input = torch.randn(22，18，12，52，102): 这里我们用 torch.randn()函数来描述输入输出变量。
- 打印(输出)用于使用 print()函数打印输出。
# Importing libraries
import torch
import torch.nn as nn
# Declaring the variable by using square kernels and equal stride
c = nn.Conv3d(18, 35, 5, stride=2)
# Declaring the variable by using non-square kernels and unequal stride with padding
p = nn.Conv3d(18, 35, (5, 7, 4), stride=(4, 3, 3), padding=(6, 4, 0))
# Describing the input and output variables
input = torch.randn(22, 18, 12, 52, 102)
output = p(input)
# Print output
print(output)
输出:
在下面的输出中，我们可以看到 PyTorch Conv3d 填充值打印在屏幕上。
PyTorch Conv3d padding
至此，我们了解了 PyTorch Conv3d 衬垫。
阅读: PyTorch nn 线性+例题
PyTorch Conv3d 组
在本节中，我们将学习 python 中的 PyTorch Conv3d 组。
PyTorch Conv3d 组用于控制输入和输出之间的连接。组的默认值为 1。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch 和 import torch.nn as nn。
- g = nn。Conv3d(20，37，7，stride=2) 用于使用平方核和等步长声明变量。
- input = torch.randn(24，20，14，54，104) 用于通过 torch.randn()函数描述输入变量。
- 打印(输出)用于使用 print()函数打印输出。
# Importing libraries
import torch
import torch.nn as nn
# Declaring the variable by using square kernels and equal stride
g = nn.Conv3d(20, 37, 7, stride=2)
# Describing the input and output variables
input = torch.randn(24, 20, 14, 54, 104)
output = g(input)
# Print output
print(output)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch Conv3d 组值被打印在屏幕上。
PyTorch Conv3d group
这就是我们对 PyTorch Conv3d 集团的理解。
PyTorch conv3d 扩张
在本节中，我们将学习 python 中的 PyTorch Conv3d 膨胀。
PyTorch Conv3d 膨胀用于控制内核元素之间的间距，膨胀的默认值为 1。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch 和 import torch.nn as nn。
- c = nn。Conv3d(18，35，5，stride=2): 这里我们通过使用平方核和等跨距来声明变量。
- p = nn。Conv3d(18，35，(5，7，4)，stride=(4，3，3)，padding=(6，4，0)): 这里我们通过使用非方形内核和带 padding 的不相等步幅来声明变量。
- q = nn。Conv3d(18，35，(5，7，4)，stride=(4，3，3)，padding=(6，4，0)，exploation =(5，3，1)): 这里我们通过使用非方核和带 padding 和 exploation 的不等步幅来声明变量。
- input = torch.randn(22，18，12，52，102): 这里我们用 torch.randn()函数来描述变量。
- 打印(输出)用于使用 print()函数打印输出。
# Importing libraries
import torch
import torch.nn as nn
# Declaring the variable by using square kernels and equal stride
c = nn.Conv3d(18, 35, 5, stride=2)
# Declaring the variable by using non-square kernels and unequal stride with padding
p = nn.Conv3d(18, 35, (5, 7, 4), stride=(4, 3, 3), padding=(6, 4, 0))
# Declaring the variable by using non-square kernels and unequal stride with padding and dilation
q = nn.Conv3d(18, 35, (5, 7, 4), stride=(4, 3, 3), padding=(6, 4, 0), dilation=(5,3,1))
# Describing the input and output variables
input = torch.randn(22, 18, 12, 52, 102)
output = q(input)
# Print output
print(output)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch Conv3d 膨胀值打印在屏幕上。
PyTorch Conv3d dilation
这样，我们理解了 python 中 PyTorch 膨胀的工作原理。
PyTorch Conv3d 偏置
在本节中，我们将学习 python 中的 PyTorch Conv3d bias 。
在前进之前，我们应该有一个关于偏见的知识。偏差考虑了模型预测和真实结果之间的差异。
PyTorch Conv3d 偏差在其值为真时向输出添加可学习偏差，如果为假，则不向输出添加可学习偏差。bias 的默认值为 True。
代码:
在下面的代码中，我们将导入 torch 库，如 import torch。
- inp = torch.ones(4，4，9，9): 这里我们用 torch.ones()函数来描述输入变量。
- c = torch . nn . Conv3d(in _ channels = 1，out_channels = 1，kernel_size = 3): 这里我们使用的是 Conv3d()函数。
- print("Parameters = "，list(c.parameters())) 用于使用 print()函数打印参数列表。
- print("bias = "，c.bias) 用于通过 print()函数打印偏差。
# Import library
import torch
# Describe the input variable
inp = torch.ones(4,4,9,9)
print("Input = ",inp)
# Using conv3d module
c = torch.nn.Conv3d(in_channels = 1, out_channels = 1, kernel_size = 3)
# Print the list of the parametrs
print("Net = ",c)
print("Parameters = ",list(c.parameters()))
# Print the bias
print("bias = ",c.bias)
输出:
运行上述代码后，我们得到以下输出，可以看到 PyTorch Conv3d 偏置值打印在屏幕上。
PyTorch Conv3d bias
至此，我们借助一个例子了解了 PyTorch Conv3d 偏置。
阅读: PyTorch 车型总结
美国有线电视新闻网 py torch Conv3d
在本节中，我们将使用 python 了解 CNN 中的 PyTorch Conv3d。
在继续之前，我们应该有一些关于卷积神经网络(CNN)的知识。
卷积神经网络是一种用于图像识别的人工神经网络。
这里我们使用 PyTorch Conv3d 来处理卷积神经网络。这是一个简单的数学运算，其中我们在三维数据上滑动一个权重矩阵或核心，并与数据执行逐元素乘法。
代码:
在下面的代码中，首先我们将导入所有必要的库，如导入 torch、从 torch . autograded 导入变量、导入 torchvision.datasets、导入 torch.nn.init。
- traindata = dtsets。MNIST(root='MNIST 数据/'，train =真，transform =变换。ToTensor()，download=True) 被用作训练 MNIST 数据集。
- print('Training dataset:\t '，traindata) 用于使用 print()函数打印训练数据集。
- 类 CNN(torch.nn.Module): 用于借助 init()和 forward()方法创建模型类。
CNNmodel = CNN()用于创建模型的实例。
# Importuing libraries
import torch
from torch.autograd import Variable
import torchvision.datasets as dtsets
import torchvision.transforms as transforms
import torch.nn.init
# hyperparameters
batch_size = 24
keepprobab = 1
# MNIST dataset
traindata = dtsets.MNIST(root='MNIST_data/',
train=True,
transform=transforms.ToTensor(),
download=True)
testdata = dtsets.MNIST(root='MNIST_data/',
train=False,
transform=transforms.ToTensor(),
download=True)
# dataset loader
dataloader = torch.utils.data.DataLoader(dataset=traindata,
batch_size=batch_size,
shuffle=True)
# Display informations about the dataset
print('Training dataset:\t',traindata)
print('\nTesting dataset:\t',testdata)
# Define the CNN Model class
class CNN(torch.nn.Module):
def __init__(self):
super(CNN, self).__init__()
self.layer1 = torch.nn.Sequential(
torch.nn.Conv3d(1, 24, kernel_size=3, stride=1, padding=1),
torch.nn.ReLU(),
torch.nn.MaxPool2d(kernel_size=2, stride=2),
torch.nn.Dropout(p=1 - keepprobab))
self.layer2 = torch.nn.Sequential(
torch.nn.Conv3d(24, 56, kernel_size=3, stride=1, padding=1),
torch.nn.ReLU(),
torch.nn.MaxPool2d(kernel_size=2, stride=2),
torch.nn.Dropout(p=1 - keepprobab))
self.layer3 = torch.nn.Sequential(
torch.nn.Conv3d(56, 120, kernel_size=3, stride=1, padding=1),
torch.nn.ReLU(),
torch.nn.MaxPool2d(kernel_size=2, stride=2, padding=1),
torch.nn.Dropout(p=1 - keepprobab))
self.fc1 = torch.nn.Linear(4 * 4 * 120, 627, bias=True)
torch.nn.init.xavier_uniform(self.fc1.weight)
self.layer4 = torch.nn.Sequential(
self.fc1,
torch.nn.ReLU(),
torch.nn.Dropout(p=1 - keepprobab))
# L5 Final FC 627 inputs -> 12 outputs
self.fc2 = torch.nn.Linear(627, 12, bias=True)
# initialize parameters
torch.nn.init.xavier_uniform_(self.fc2.weight)
def forward(self, y):
output = self.layer1(y)
output = self.layer2(output)
output = self.layer3(output)
# Flatten them for FC
output = output.view(output.size(0), -1)
output = self.fc1(output)
output = self.fc2(output)
return output
#instantiate CNN model
CNNmodel = CNN()
CNNmodel
输出:
在下面的输出中，我们可以看到 CNN 模型中的 PyTorch Conv3 打印在屏幕上。
PyTorch Conv3d in CNN
这就是我们如何在 CNN 中使用 PyTorch Conv3d 并创建 CNN 模型。
阅读: PyTorch 逻辑回归
PyTorch Conv3d 转译
在本节中，我们将学习 python 中的 PyTorch Conv3d transpose 。
PyTorch Conv3d 转置对从一些输入平面收集的输入图像应用 3d 转置卷积运算符。
语法:
PyTorch Conv3d 转置的语法
torch.nn.ConvTranspose3d(in_channels, out_channels, kernel_size, stride=1, padding=0, out_padding=0, groups=1, bias=True, dilation=1, padding_mode='zeros', device=None, dtype=None)
参数:
以下是 PyTorch Conv3d 转置的参数。
in_channels是输入图像中的通道数。out_channels是卷积产生的通道数。kernel_size用作卷积核的大小。- 步距用于根据互相关控制步距。
- 填充用于控制隐式零填充的数量。
- outpu_padding 用于控制添加到输出形状一侧的额外大小。
- 膨胀用于控制内核点之间的间距。
- 组用于控制输入和输出之间的连接。
举例:
在下面的代码中，我们将导入所有必要的库，如 import torch，import torch.nn as nn。
- c = nn。ConvTranspose3d(16，33，3，stride=2) 用平方核和等步距来描述变量。
- c = nn。ConvTranspose3d(16，33，(3，5，2)，stride=(2，1，1)，padding=(0，4，2)) 用于用非方核和带 padding 的不等步长来描述变量。
- inp = torch.randn(20，16，10，50，100): 这里我们用 torch.randn()函数来描述输入变量。
print(outp)用于使用 print()函数打印输出。
# Importing Libraries
import torch
import torch.nn as nn
# Describing the variable by using square kernels and equal stride
c = nn.ConvTranspose3d(16, 33, 3, stride=2)
# Describing the variable by using non-square kernels and unequal stride and with padding
c = nn.ConvTranspose3d(16, 33, (3, 5, 2), stride=(2, 1, 1), padding=(0, 4, 2))
# Declaring the input variable
inp = torch.randn(20, 16, 10, 50, 100)
outp = c(inp)
# Print output
print(outp)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch Conv3d 转置值打印在屏幕上。
PyTorch Conv3d transpose
至此，我们借助一个例子了解了 PyTorch Conv3d 转置。
阅读: PyTorch 模型评估+示例
PyTorch Conv3d 参数
在本节中，我们将学习 python 中的 PyTorch Conv3d 参数。
在继续之前，我们应该了解一些关于参数的知识。参数是作为描述系统或设定其操作条件的集合之一而建立的可测量因素。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch 和 import torch.nn as nn。
- k = nn。Conv3d(22，39，9，stride=2) 用平方核和等步距来描述变量。
- inp = torch.randn(26，22，16，56，106): 这里我们用 torch.randn()函数来描述输入变量。
print(out)用于使用 print()函数打印输出。
# Importing libraries
import torch
import torch.nn as nn
# Declaring the variable by using square kernels and equal stride
k = nn.Conv3d(22, 39, 9, stride=2)
# Describing the input and output variables
inp = torch.randn(26, 22, 16, 56, 106)
out = k(inp)
# Print output
print(out)
输出:
在下面的输出中，我们可以看到 PyTorch Conv3d 参数值打印在屏幕上。
PyTorch Conv3d parameters
这就是我们描述 conv3d 参数和进行算术运算的方式。
PyTorch Conv3d weight
在本节中，我们将学习 python 中的 PyTorch Conv3d weight 。
PyTorch Conv3d 权重用于对 3d 数据和一些附加选项(如填充等)执行卷积。
代码:
在下面的代码中，我们将导入 torch 库，如 import torch。
- inpt = torch.ones(1，1，3，3，3): 这里我们用 torch.ones()函数来描述输入变量。
- print("Input = "，inpt) 用于通过 print()函数打印输入。
- w = torch . nn . Conv3d(in _ channels = 1，out_channels = 1，kernel_size = 3): 这里我们使用的是 conv 3d()函数。
- print("Parameters = "，list(w.parameters())) 用于打印参数列表。
- print("Weight = "，w.weight) 用于打印重量。
- print("Output = "，out) 用于借助 print()函数打印输出。
# Import library
import torch
# Describe the input variable
inpt = torch.ones(1,1,3,3,3)
# Print input
print("Input = ",inpt)
w = torch.nn.Conv3d(in_channels = 1, out_channels = 1, kernel_size = 3)
# Print the parameter list
print("net = ",w)
print("Parameters = ",list(w.parameters()))
# Print the weight
print("Weight = ",w.weight)
# Print the bias
print("bias = ",w.bias)
out = w(inpt)
print("Output = ",out)
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到 PyTorch Conv3d 重量打印在屏幕上。
PyTorch Conv3d weight
这就是我们对 PyTorch Conv3d 重量的理解。
阅读: PyTorch 查看教程
PyTorch Conv3d 输入 _ 通道和输出 _ 通道
在本节中，我们将学习 python 中的 PyTorch Conv3d input_channels 和 output_channels 。
PyTorch Conv3d input_channels 用作输入图像中的通道数。
PyTorch Conv3d output_channels 用作卷积产生的通道数。
代码:
在下面的代码中，首先我们将导入所有必要的库，如导入 torch、从 torch.autograd 导入变量、将 torch.nn 作为 nn 导入、导入 torch.nn.functional。
- 级 mod(nn。Module): 这里我们借助 init()和 forward()函数创建一个模型类。
- size = y.size()[1:] 用作除批量维度以外的所有维度。
model = mod()被用作模型的实例。print(model)用于通过 print()函数打印模型。
# Importing Libraries
import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as fun
# Create model class
class mod(nn.Module):
def __init__(self):
super(mod, self).__init__()
# 1 input image channel, 10 output channels, 9x9 square convolution
self.conv1 = nn.Conv3d(1, 10, 9)
self.conv2 = nn.Conv3d(10, 20, 9)
# an affine operation: y = Wx + b
self.fc1 = nn.Linear(20 * 9 * 9, 142)
self.fc2 = nn.Linear(142, 88)
self.fc3 = nn.Linear(88, 14)
def forward(self, y):
# Max pooling over a (2, 2) window
y = fun.max_pool2d(fun.relu(self.conv1(y)), (2, 2))
# If the size is a square you can only specify a single number
y = fun.max_pool2d(fun.relu(self.conv2(y)), 2)
y = y.view(-1, self.numflat_featurs(y))
y = fun.relu(self.fc1(y))
y = fun.relu(self.fc2(y))
y = self.fc3(y)
return y
def numflat_featurs(self, y):
# all dimensions except the batch dimension
size = y.size()[1:]
numfeaturs = 1
for i in size:
numfeaturs *= i
return numfeaturs
# Instantiate the model
model = mod()
# Print the model
print(model)
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到 PyTorch Conv3d input_channels 和 output_channels 值打印在屏幕上。
PyTorch Conv3d input_channels and output_channels
至此，我们了解了 PyTorch Conv3d 输入通道和输出通道。
另外，看看更多的 Python PyTorch 教程。
因此，在本教程中，我们讨论了 PyTorch Conv3d ，并且我们还讨论了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- 什么是 PyTorch Conv3d
- PyTorch Conv3d 示例
- PyTorch 泛函 Conv3d
- PyTorch Conv3d 填充
- PyTorch Conv3d 集团
- PyTorch conv3d 扩展
- PyTorch Conv3d 偏置
- CNN 的 PyTorch Conv3d
- PyTorch Conv3d 转置
- PyTorch Conv3d 参数
- PyTorch Conv3d 权值
- PyTorch Conv3d 输入通道和输出通道
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
资料载入器+范例
在本 Python 教程中，我们将学习 Python 中的 PyTorch Dataloader ，我们还将涵盖与 PyTorch Dataloader 相关的不同示例。此外，我们将涵盖这些主题。
- 资料载入器游标
- PyTorch 数据加载器示例
- 来自目录的 PyTorch 数据加载器
- PyTorch 数据加载器训练测试拆分
- 文本数据加载器
- Cuda 数据加载器
- PyTorch 数据加载器数量 _ 工作线程
- pyzer 数据加载器添加尺寸
- PyTorch 数据加载器访问数据集
- 批次大小资料载入器游标
- PyTorch dataloader epoch
- PyTorch dataloader enumerate
- dataloader 资料框游标
- 批量取样器数据加载器
目录
- 数据加载器指针
- PyTorch 数据加载器示例
- 目录中的 PyTorch 数据加载器
- PyTorch 数据加载器列车测试分割
- 文本数据加载器指针
- 数据加载器指针 Cuda
- py torch data loader num _ workers
- Pytorch dataloder 添加尺寸
- PyTorch dataloader 访问数据集
- 数据加载器指针批量大小
- PyTorch dataloader epoch
- PyTorch dataloader enumerate
- 数据加载器数据帧指针
- 数据加载器指针批量采样器
数据加载器指针
在本节中，我们将了解 PyTorch 数据加载器如何在 python 中工作。
数据加载器被定义为组合数据集并提供给定数据集的迭代的过程。Dataloader 还用于导入或导出数据。
语法:
以下是在 PyTorch 中使用 Dataloader 的语法:
DataLoader(dataset,batch_size=1,shuffle=False,sampler=None,batch_sampler=None,num_workers=0,collate_fn=None,pin_memory=False,drop_last=False,timeout=0,worker_init_fn=None)
参数:
数据加载器语法中使用的参数:
- 数据集:data loader 类必须使用数据集进行构建。
- batch_size: 每批的样本数。
- 洗牌:当我们要对数据进行洗牌时使用。
- 取样器:取样器定义回收样品的方案。
- Batch_sampler: 与数据样本相同。
- num_workers: 加载数据的进程数。
- collate_fn: 将样本整理成批次。
- pin _ memory:GPU 用于快速访问数据的位置。
- drop_last: 最后一批中的元素数量少于 batch_size。
- 超时:用于设置从工人处领取批次时等待的时间。
- worker_init_fn: 允许客户的套路。
此外，检查: Keras 与 py torch–主要差异
PyTorch 数据加载器示例
在本节中，我们将借助 python 中的例子来了解如何在 PyTorch 中实现 dataloader。
在这个 dataloader 示例中，我们可以导入数据，然后导出数据。数据加载器可以使数据加载变得非常容易。
代码:
在下面的代码中，我们将导入一些可以从中加载数据的库。
- warnings . filter warnings(' ignore ')用于忽略警告。
plot.ion()用于打开非活动模式。- landmark frame = PDS . read _ csv(' face _ landmarks . CSV ')用于读取 CSV 文件。
- landmarkFrame.iloc[x，0] 用作基于整数位置的索引。
num.asarray(landmark)用于将输入转换为数组。- 打印('图像名称:{} '。【T1 格式(imagename))】用于打印屏幕上的图像名称。
- 打印('地标形状:{} '。格式(landmark.shape)) 用于打印屏幕上的地标形状。
- 打印('前六个地标:{} '。format(landmark[:6])用于打印屏幕上的前六个地标。
from __future__ import print_function, division
import os
import torch
import pandas as pds
from skimage import io, transform
import numpy as num
import matplotlib.pyplot as plot
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms, utils
import warnings
warnings.filterwarnings('ignore')
plot.ion()
landmarkFrame = pds.read_csv('face_landmarks.csv')
x = 67
imagename = landmarkFrame.iloc[x, 0]
landmark = landmarkFrame.iloc[x, 1:]
landmark = num.asarray(landmark)
landmark = landmark.astype('float').reshape(-3, 4)
print('Image Name: {}'.format(imagename))
print('Landmark Shape: {}'.format(landmark.shape))
print('First Six Landmark: {}'.format(landmark[:6]))
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到屏幕上打印出了 ImageName 、 Landmark Shape 和前六个 Landmark 。
PyTorch dataloader example
阅读: PyTorch 保存模型
目录中的 PyTorch 数据加载器
在本节中，我们将从 python 中的目录中了解到 PyTorch 数据加载器。
Dataloader 从目录中获取数据集。目录被定义为文件或子目录的集合。
代码:
在下面的代码中，我们将导入一些库，从中我们可以加载目录中的数据。
- 训练数据=数据集。FashionMNIST() 作为训练数据集。
- 测试数据=数据集。使用 FashionMNIST() 作为测试数据集。
- train dl = data loader(training data，batch_size=60，shuffle=True) 用于加载训练数据。
- testdl = DataLoader(test_data，batch_size=60，shuffle=True) 用于加载测试数据。
- print(f "特征批次造型:{ train Feature . size()} "用于打印特征批次造型。
- print(f " Label Batch Shape:{ train Label . size()} "用于打印标签批次特征。
- plot.imshow(imgdir，cmap="gray") 用于在屏幕上绘制图像。
- print(f " Labels:{ Labels } "用于在屏幕上打印标签。
import torch
from torch.utils.data import Dataset
from torchvision import datasets
from torchvision.transforms import ToTensor
import matplotlib.pyplot as plot
trainingdata = datasets.FashionMNIST(
root="data",
train=True,
download=True,
transform=ToTensor()
)
testdata = datasets.FashionMNIST(
root="data",
train=False,
download=True,
transform=ToTensor()
)
from torch.utils.data import DataLoader
traindl = DataLoader(trainingdata, batch_size=60, shuffle=True)
testdl = DataLoader(test_data, batch_size=60, shuffle=True)
# Display image and label.
trainfeature, trainlabel = next(iter(traindl))
print(f"Feature Batch Shape: {trainfeature.size()}")
print(f"Label Batch Shape: {trainlabel.size()}")
imgdir = trainfeature[0].squeeze()
labels = trainlabel[0]
plot.imshow(imgdir, cmap="gray")
plot.show()
print(f"Labels: {labels}")
输出:
在下面的输出中，我们可以看到数据加载器可以从目录中加载数据并将其打印在屏幕上。
PyTorch dataloader from the directory
阅读: PyTorch 负载模型+示例
PyTorch 数据加载器列车测试分割
在这一节中，我们将了解数据加载器如何将数据分割成 train 并在 python 中测试。
训练测试分割是一个计算模型性能并查看我们的模型执行的准确性的过程。
代码:
在下面的代码中，我们将导入一些库，dataloader 可以从这些库中将数据分成 train 和 test。
- 变换。Compose() 用于声明将原始数据转换为张量的变换。
- traindata，test data = random _ split(train data，[50000，10000]) 用于将数据拆分成训练和测试。
- train _ loader = data loader(train data，batch_size=32) 用于创建一个批量数据加载器。
- optimizer = torch . optim . SGD(models . parameters()、lr = 0.01) 用于初始化优化器。
- print(f'Epoch {i+1} \t\t 训练数据:{ train loss/len(train _ loader)} \ t \ t 测试数据:{ Test loss/len(Test _ loader)} ')用于打印训练和测试数据。
- torch . save(models . state _ dict()，' saved_model.pth') 用于保存状态 dict。
import torch
from torch import nn
import torch.nn.functional as fun
from torchvision import datasets, transforms
from torch.utils.data import DataLoader, random_split
import numpy as num
transform = transforms.Compose([
transforms.ToTensor()
])
traindata = datasets.MNIST('', train = True, transform = transform, download = True)
traindata,testdata = random_split(traindata,[50000,10000])
train_loader = DataLoader(traindata, batch_size=32)
test_loader = DataLoader(testdata, batch_size=32)
**# Building Our Mode**
class network(nn.Module):
def __init__(self):
super(network,self).__init__()
self.fc = nn.Linear(28*28, 256)
self.fc1 = nn.Linear(256, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, y):
y = y.view(y.shape[0],-1)
y = fun.relu(self.fc(y))
y = fun.relu(self.fc1(y))
y = self.fc2(y)
return y
models = network()
if torch.cuda.is_available():
models = models.cuda()
criterions = nn.CrossEntropyLoss()
optimizers = torch.optim.SGD(models.parameters(), lr = 0.01)
epoch = 7
minvalid_loss = num.inf
for i in range(epoch):
trainloss = 0.0
models.train()
for data, label in train_loader:
if torch.cuda.is_available():
data, label = data.cuda(), label.cuda()
optimizers.zero_grad()
targets = models(data)
loss = criterions(targets,label)
loss.backward()
optimizers.step()
trainloss += loss.item()
testloss = 0.0
models.eval()
for data, label in test_loader:
if torch.cuda.is_available():
data, label = data.cuda(), label.cuda()
targets = models(data)
loss = criterions(targets,label)
testloss = loss.item() * data.size(0)
print(f'Epoch {i+1} \t\t Training data: {trainloss / len(train_loader)} \t\t Test data: {testloss / len(test_loader)}')
if minvalid_loss > testloss:
print(f'Test data Decreased({minvalid_loss:.6f}--->{testloss:.6f}) \t Saving The Model')
minvalid_loss = testloss
torch.save(models.state_dict(), 'saved_model.pth')
输出:
在下面的输出中，我们可以看到 PyTorch Dataloader spit train 测试数据被打印在屏幕上。
PyTorch dataloader train test split
阅读: PyTorch nn 线性+例题
文本数据加载器指针
在本节中，我们将了解 PyTorch 数据加载器如何为 python 中的文本工作。
Dataloader 组合数据集，并提供给定数据集的迭代。Dataset 存储所有数据，dataloader 用于转换数据。
代码:
在下面的代码中，我们将导入 torch 模块，以便从 dataloader 加载文本。
- train iteration = AG _ NEWS(split = ' train ')用于将整个数据拆分成列车数据。
- 打印(标签，线条)用于打印标签和线条。
- data loaders = data loader(train iteration，batch_size=5，shuffle=False) 用于加载数据。
from torchtext.datasets import AG_NEWS
trainiteration = AG_NEWS(split='train')
**# Iterate with for loop**
for (labels, lines) in trainiteration:
print(labels, lines)
**# send to DataLoader**
from torch.utils.data import DataLoader
trainiteration = AG_NEWS(split='train')
dataloaders = DataLoader(trainiteration, batch_size=5, shuffle=False)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到文本数据的 PyTorch 数据加载器打印在屏幕上。
PyTorch dataloader for text
数据加载器指针 Cuda
在本节中，我们将学习 python 中的 PyTorch 数据加载器 Cuda 。
在继续之前，我们应该了解一些关于 Cuda 的知识。Cuda 是一个应用程序编程接口，允许软件使用特定类型的 GPU。
代码:
在下面的代码中，我们将导入一个 torch 模块，我们可以通过 dataloader 从该模块加载数据。
- traindata =数据集。MNIST() 被用作训练数据集。
trainloader = DataLoader()用于加载列车数据。- train data . train _ data . to(torch . device(" cuda:0 "))用于将数据全部放入 GPU。
import torch
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision import transforms
batchsize = 60
transforms = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1304,), (0.3080,))
])
traindata = datasets.MNIST(
root='./dataset/minst/',
train=True,
download=False,
transform=transforms
)
trainloader = DataLoader(
dataset=traindata,
shuffle=True,
batch_size=batchsize
)
traindata.train_data.to(torch.device("cuda:0"))
traindata.train_labels.to(torch.device("cuda:0"))
输出:
运行上述代码后，我们得到以下输出，从中我们可以看到数据被放入 GPU，并在 dataloader 的帮助下加载到屏幕上。
PyTorch dataloader Cuda
py torch data loader num _ workers
在本节中，我们将学习 python 中的 PyTorch 数据加载器 num_workers 。
num _ workersis 定义为提供创建批处理的进程数的进程。
代码:
在下面的代码中，我们将导入一些模块，dataloader num_workers 从这些模块创建 baches。
- 变换。Compose() 用于定义转换以规范化数据。
- train _ loader = torch.utils.data . data loader(train _ set，batch_size=60，shuffle=True) 来自 torch . utils . data 导入数据集，用于加载训练数据。
- datasets=SampleDataset(2，440) 用于创建样本数据集。
- dloader = DataLoader(datasets，batch_size=10，shuffle=True，num_workers=4 ) 用于加载批处理。
- print(x，batch) 用于打印批次。
import torch
import matplotlib.pyplot as plot
from torchvision import datasets, transforms
transforms = transforms.Compose([transforms.ToTensor(),
transforms.Normalize((0.5,), (0.3,)),
])
train_set = datasets.MNIST('~/.pytorch/MNIST_data/', download=True, train=True, transform=transforms)
train_loader = torch.utils.data.DataLoader(train_set, batch_size=60, shuffle=True)
from torch.utils.data import Dataset
import random
class SampleDataset(Dataset):
def __init__(self,r,r1):
random_list=[]
for x in range(2,999):
m = random.randint(r,r1)
random_list.append(m)
self.samples=random_list
def __len__(self):
return len(self.samples)
def __getitem__(self,idx):
return(self.samples[idx])
datasets=SampleDataset(2,440)
datasets[90:100]
from torch.utils.data import DataLoader
dloader = DataLoader(datasets,batch_size=10, shuffle=True, num_workers=4 )
for x, batch in enumerate(dloader):
print(x, batch)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 数据加载器 num_workers 数据被打印在屏幕上。
PyTorch dataloader num_worker
Pytorch dataloder 添加尺寸
在本节中，我们将了解到 PyTorch dataloader 如何在 python 中添加维度。
PyTorch 中的 dataloader 似乎在 batch 维度之后添加了一些额外的维度。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以添加一个维度。
- mnisttrain_data = MNIST(root= '。/data '，train=True，download=True，transform =转换。撰写([转换。ToTensor()])) 用于从 mnist 数据集加载数据。
- 打印(y.shape) 用于打印 y 的形状
- train loader _ data = torch . utils . data . data loader(mnist train _ data，batch_size=150) 用于加载列车数据。
- batch_y，batch _ z = next(ITER(train loader _ data))用于获取第一批。
print(batch_y.shape)用于打印批量的形状。
import torch
from torchvision.datasets import MNIST
from torchvision import transforms
if __name__ == '__main__':
mnisttrain_data = MNIST(root='./data', train=True, download=True, transform=transforms.Compose([transforms.ToTensor()]))
y = mnisttrain_data.data[1]
print(y.shape)
trainloader_data = torch.utils.data.DataLoader(mnisttrain_data, batch_size=150)
batch_y, batch_z = next(iter(trainloader_data))
print(batch_y.shape)
输出:
运行上面的代码后，我们得到下面的输出，从中我们可以看到维度将被添加。
PyTorch dataloader add dimension
阅读: PyTorch 批量标准化
PyTorch dataloader 访问数据集
在本节中，我们将学习如何在 python 中的数据加载器的帮助下访问数据集。
数据集包含一个围绕数据集的 iterable，它授权访问样本。
代码:
在下面的代码中，我们将导入数据加载器可以从中访问数据集的 torch 模块。
- figure _ data = plot . figure(figsize =(9，9)) 用于绘制图形。
- sample _ index = torch . randint(len(train data)，size=(1，)。【T1 项()】用于生成随机样本项。
- figure _ data . add _ subplot(rows，columns，x) 用于添加一些支线剧情。
- plot . title(label map _ dt[labels])用于在屏幕上绘制标题。
- plot.imshow(image.squeeze()、cmap="gray") 用于显示屏幕上的图像。
import torch
from torch.utils.data import Dataset
from torchvision import datasets
from torchvision.transforms import ToTensor
import matplotlib.pyplot as plot
traindata = datasets.FashionMNIST(
root="data",
train=True,
download=True,
transform=ToTensor()
)
testdata = datasets.FashionMNIST(
root="data",
train=False,
download=True,
transform=ToTensor()
)
labelmap_dt = {
0: "Skirt",
1: "Top",
2: "Muffler",
3: "Western_dress",
4: "Pant_coat",
5: "Snikers",
6: "T-shirt",
7: "Sandles",
8: "Purse",
9: "Shoes",
}
figure_data = plot.figure(figsize=(9,9))
columns, rows = 4, 4
for x in range(1, columns * rows + 1):
sample_index = torch.randint(len(traindata), size=(1,)).item()
image, labels = traindata[sample_index]
figure_data.add_subplot(rows, columns, x)
plot.title(labelmap_dt[labels])
plot.axis("off")
plot.imshow(image.squeeze(), cmap="gray")
plot.show()
输出:
以下输出显示数据加载器可以访问数据集，并且图像和标签绘制在屏幕上。
PyTorch dataloader access dataset
数据加载器指针批量大小
在本节中，我们将学习如何借助 python 中的 dataloader 加载批量大小。
批量定义为模型更新前处理的样本数量。批量大小等于训练数据中的样本数。
代码:
在下面的代码中，我们将导入 torch 模块，在模型更新之前，我们可以从该模块处理样本数。
datasets = imp dataset(1001)作为数据集使用。- data loader = data loader(datasets，batch_size=15) 用于加载批量为 15 的数据。
len(dataloader)用作 dataloader 的长度。- 打印('批次索引{}，批次长度{} '。(batchindex，len(data))【格式】用于打印屏幕上的批次索引、批次长度。
import torch
from torch.utils.data import Dataset
from torchvision import datasets
from torchvision.transforms import ToTensor
from torch.utils.data import DataLoader
class impdataset(Dataset):
def __init__(self, siz):
self.y = torch.randn(siz, 1)
def __getitem__(self, idx):
return self.y[idx]
def __len__(self):
return len(self.y)
datasets = impdataset(1001)
dataloader = DataLoader(datasets,batch_size=15)
len(dataloader)
for batchindex, data in enumerate(dataloader):
print('batch index{}, batch length {}'.format(batchindex, len(data)))
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 dataloader 批处理大小打印在屏幕上。
PyTorch dataloader batch size
阅读: PyTorch MNIST 教程
PyTorch dataloader epoch
在本节中，我们将了解 PyTorch dataloader epoch 如何在 python 中工作。
在前进之前，我们应该有一个关于时代的知识。纪元被定义为时间开始的点。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以加载 dataloader epoch 以开始工作。
- traindt =数据集。MNIST("，train = True，transform = transform，download = True) 用作训练数据。
- train _ loader = data loader(train dt，batch_size=30) 用作训练加载器。
- test _ loader = data loader(testdt，batch_size=30) 用作测试加载器。
- optimizer = torch . optim . SGD(models . parameters()、lr = 0.01) 用于初始化优化器。
optimizer . zero _ grad()用于优化零梯度。- print(f'Epoch {x+1} \t\t 训练数据:{ train loss/len(train _ loader)} \ t \ t 测试数据:{ Test loss/len(Test _ loader)} ')用于在屏幕上打印训练和测试数据。
import torch
from torch import nn
import torch.nn.functional as func
from torchvision import datasets, transforms
from torch.utils.data import DataLoader, random_split
import numpy as num
transform = transforms.Compose([
transforms.ToTensor()
])
traindt = datasets.MNIST('', train = True, transform = transform, download = True)
traindt,testdt = random_split(traindt,[50000,10000])
train_loader = DataLoader(traindt, batch_size=30)
test_loader = DataLoader(testdt, batch_size=30)
class network(nn.Module):
def __init__(self):
super(network,self).__init__()
self.fc = nn.Linear(28*28, 254)
self.fc1 = nn.Linear(254, 126)
self.fc2 = nn.Linear(126, 10)
def forward(self, y):
y = y.view(y.shape[0],-1)
y = func.relu(self.fc(y))
y = func.relu(self.fc1(y))
y = self.fc2(y)
return y
models = network()
if torch.cuda.is_available():
models = models.cuda()
criterions = nn.CrossEntropyLoss()
optimizers = torch.optim.SGD(models.parameters(), lr = 0.01)
epoch = 5
minvalid_loss = num.inf
for x in range(epoch):
trainloss = 0.0
models.train()
for data, label in train_loader:
if torch.cuda.is_available():
data, label = data.cuda(), label.cuda()
optimizers.zero_grad()
targets = models(data)
loss = criterions(targets,label)
loss.backward()
optimizers.step()
trainloss += loss.item()
testloss = 0.0
models.eval()
for data, label in test_loader:
if torch.cuda.is_available():
data, label = data.cuda(), label.cuda()
targets = models(data)
loss = criterions(targets,label)
testloss = loss.item() * data.size(0)
print(f'Epoch {x+1} \t\t Training data: {trainloss / len(train_loader)} \t\t Test data: {testloss / len(test_loader)}')
输出:
在下面的输出中，我们可以看到带有 epoch 的训练数据和测试数据被打印在屏幕上。
PyTorch dataloader epoch
阅读: PyTorch 全连接层
PyTorch dataloader enumerate
在本节中，我们将学习 python 中的py torch data loader enumerate。
数据加载器组合数据集，并在给定的数据集上提供迭代，枚举被定义为一个过程，一个一个地提到事物的数量。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以枚举数据。
- num = list(范围(0，90，2)) 用于定义列表。
- data _ loader = DataLoader(dataset，batch_size=12，shuffle=True) 用于在数据集上实现 data loader，并按批次打印。
- print(x，batch) 用于逐个打印批次号。
import torch
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
**# define the Dataset class**
class dataset(Dataset):
def __init__(self):
num = list(range(0, 90, 2))
self.data = num
def __len__(self):
return len(self.data)
def __getitem__(self, idx):
return self.data[idx]
dataset = dataset()
data_loader = DataLoader(dataset, batch_size=12, shuffle=True)
for x, batch in enumerate(data_loader):
print(x, batch)
输出:
在运行上面的代码之后，我们得到了下面的输出，其中我们可以看到批处理被一个接一个地打印在屏幕上。
PyTorch dataloader enumerate
数据加载器数据帧指针
在本节中，我们将学习如何使用 python 中的 dataframe 加载数据。
数据帧被定义为具有行和列的二维异构数据结构，数据加载器使用数据帧来加载数据。
代码:
在下面的代码中，我们将导入一些可以从中加载数据的库。
- dt = num.loadtxt('heart.csv '，delimiter= '，'，dtype=num.float32，skiprows=1) 用于从 path 加载 csv 文件。
- self.a = torch.from_numpy(dt[:，:11]) 作为类标签作为 11 列使用。
- seconddata = dataset[1] 用于获取第二个样本并解包。
import torch
import torchvision
from torch.utils.data import Dataset, DataLoader
import numpy as num
import math
class Dataset():
def __init__(self):
dt = num.loadtxt('heart.csv', delimiter=',',
dtype=num.float32, skiprows=1)
self.a = torch.from_numpy(dt[:, :11])
self.b = torch.from_numpy(dt[:, [11]])
self.nsample = dt.shape[0]
def __getitem__(self, idx):
return self.a[idx], self.b[idx]
**# we can call len(dataset) to return the size**
def __len__(self):
return self.nsample
dataset = Dataset()
seconddata = dataset[1]
feturs, lbs = seconddata
print(feturs, lbs)
输出:
运行上述代码后，我们得到以下输出，从中可以看到数据加载器可以使用数据框加载数据。
Pytorch dataloader dataframe
数据加载器指针批量采样器
在本节中，我们将学习 python 中的 PyTorch dataloader 批处理采样器。
数据加载器有一个内部使用的采样器，用于获取每个批次的索引。批次采样器在批次下定义。
代码:
- 在下面的代码中，我们将导入 torch 模块，从中我们可以获得每批的索引。
- data _ set = batchsamplerdataset(xdata，ydata) 用于定义数据集。
- batches _ sampler = data loader(data _ set)。采样器用于加载数据集。
batchsize = 2用于获取顺序采样器的迭代。- default batch _ sampler = data loader(data _ set，batch_size=batchsize)。batch_sampler 用于加载批量采样器。
- print(f ' batch # { I } indexes:'，batch _ indexes)用于打印批次和批次索引。
import torch
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
xdata = list(range(12))
ydata = list(range(12,22))
class batchsamplerdataset:
def __init__(self, xdata, ydata):
self.xdata = xdata
self.ydata = ydata
def __getitem__(self, n):
return self.xdata[n], self.ydata[n]
def __len__(self):
return len(self.xdata)
data_set = batchsamplerdataset(xdata, ydata)
data_set[2]
batches_sampler = DataLoader(data_set).sampler
for x in batches_sampler:
batchsize = 2
defaultbatch_sampler = DataLoader(data_set, batch_size=batchsize).batch_sampler
for i, batch_indices in enumerate(defaultbatch_sampler):
print(f'Batch #{i} indices: ', batch_indices)
输出:
在下面的输出中，我们可以看到 PyTorch dataloader 批处理取样器打印在屏幕上。
Pytorch dataloader batch sampler
因此，在本教程中，我们讨论了 PyTorch dataloader ，并且我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- 资料载入器游标
- PyTorch 数据加载器示例
- 来自目录的 PyTorch 数据加载器
- PyTorch 数据加载器训练测试拆分
- 文本数据加载器
- Cuda 数据加载器
- PyTorch 数据加载器数量 _ 工作线程
- PyTorch 数据加载器访问数据集
- 批次大小资料载入器游标
- PyTorch dataloader epoch
- PyTorch dataloader enumerate
- dataloader 资料框游标
- 批量取样器数据加载器
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch 提前停止+示例
在这个 Python 教程中，我们将学习 Python 中的 PyTorch 提前停止，我们还将涵盖与提前停止相关的不同示例。此外，我们将涵盖这些主题。
- PyTorch 提前停止
- PyTorch 早期停止示例
- PyTorch 提前停止调度程序
- PyTorch 闪电提前停止
- PyTorch 点火提前停止
- PyTorch 几何提前停止
- PyTorch lstm 提前停止
- PyTorch 提前停止回调
- PyTorch 验证提前停止
目录
- PyTorch 提前停止
- PyTorch 提前停止示例
- PyTorch 提前停止调度程序
- PyTorch 闪电提前停止
- PyTorch 点火提前停止
- PyTorch 几何提前停车
- PyTorch lstm 提前停止
- PyTorch 提前停止回调
- PyTorch 验证提前停止
PyTorch 提前停止
在本节中，我们将学习 python 中的 PyTorch 提前停止。
提前停止被定义为避免在训练数据集上过度拟合的过程，并且它保持在验证损失的轨道上。这里我们将讨论如何在 PyTorch 的帮助下使用早期停止过程。
语法:
提前停止的语法如下:
Early Stopping(monitor=None, min_delta=0.0,patience = 3, verbose = False, mode = min, strict = True, check_finite = True, stopping_threshold = None, divergence_threshold = None, check_on_train_epoch_end = None)
参数:
- 监控器用于监控数量。
min_delta用于监控量中非常小的变化，以符合改善条件。- 耐心用于检查没有改善的次数，超过该次数后将停止训练。
- 详细用作详细模式。
- 模式:有最小和最大两种模式。
- 最小模式用于当数量监视器停止减少时，训练将停止。
- 最大模式被使用，当数量监视器停止增加时，训练将停止。
- 如果在验证指标中找不到监视器，则无论如何都要使用严格的来进行崩溃训练。
check_finite用于在监护仪变为 Nan 时停止训练。stopping_threshold用于当监视器数量达到该阈值时，立即停止训练。divergence_threshold用于在监视器数量低于该阈值时停止训练。check_on_train_epoch_end用于在训练时期结束时提前停止运行，如果在验证结束时检查为假。
此外，检查: Adam optimizer PyTorch 和示例
PyTorch 提前停止示例
在这一节中，我们将借助 python 中的一个例子来了解提前停止的实现。
PyTorch 早期停止被定义为我们可以防止神经网络在训练数据时过度拟合的过程。
代码:
在下面的代码中，我们将导入一些库，从中我们可以训练数据并实现对数据的提前停止。
- def traindata(设备、模型、时期、优化器、loss_function、train_loader、valid_loader): 用于定义列车数据。
optimizer.zero_grad()用于优化零梯度。- output = model(input . view(input . shape[0]，-1)) 用于获取模型的输出。
- loss = loss_function(output，label) 用于计算损失。
- print('[{}/{}，{}/{}] loss: {:.8} '。format(epoch，epochs，times，len(train_loader)，loss.item()) 是打印模型的进度。
- current _ loss = validation(model，device，valid_loader，loss_function) 用于计算当前损耗。
- 打印('当前损失:'，current_loss) 用于打印当前损失。
- print('Accuracy:'，correct / total) 用于打印模型的精度。
- 损失函数= nn。NLLLoss() 用于计算损失函数。
- 优化器= optim。Adam(model.parameters()、lr=lr) 用于优化优化器。
- 变换=变换。Compose() 用于转换数据。
import torch
import torch.nn as nn
import torch.optim as optim
import torch.utils.data as data
from torchvision import datasets, transforms
**# Model architecture**
class model(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.main = nn.Sequential(
nn.Linear(in_features=786, out_features=130),
nn.ReLU(),
nn.Linear(in_features=130, out_features=66),
nn.ReLU(),
nn.Linear(in_features=66, out_features=12),
nn.LogSoftmax(dim=1)
)
def forward(self, input):
return self.main(input)
# Train
def traindata(device, model, epochs, optimizer, loss_function, train_loader, valid_loader):
** # Early stopping**
last_loss = 100
patience = 2
triggertimes = 0
for epoch in range(1, epochs+1):
model.train()
for times, data in enumerate(train_loader, 1):
input = data[0].to(device)
label = data[1].to(device)
**# Zero the gradients**
optimizer.zero_grad()
**# Forward and backward propagation**
output = model(input.view(input.shape[0], -1))
loss = loss_function(output, label)
loss.backward()
optimizer.step()
**# Show progress**
if times % 100 == 0 or times == len(train_loader):
print('[{}/{}, {}/{}] loss: {:.8}'.format(epoch, epochs, times, len(train_loader), loss.item()))
** # Early stopping**
current_loss = validation(model, device, valid_loader, loss_function)
print('The Current Loss:', current_loss)
if current_loss > last_loss:
trigger_times += 1
print('Trigger Times:', trigger_times)
if trigger_times >= patience:
print('Early stopping!\nStart to test process.')
return model
else:
print('trigger times: 0')
trigger_times = 0
last_loss = current_loss
return model
def validation(model, device, valid_loader, loss_function):
model.eval()
loss_total = 0
**# Test validation data**
with torch.no_grad():
for data in valid_loader:
input = data[0].to(device)
label = data[1].to(device)
output = model(input.view(input.shape[0], -1))
loss = loss_function(output, label)
loss_total += loss.item()
return loss_total / len(valid_loader)
def test(device, model, test_loader):
model.eval()
total = 0
correct = 0
with torch.no_grad():
for data in test_loader:
input = data[0].to(device)
label = data[1].to(device)
output = model(input.view(input.shape[0], -1))
_, predicted = torch.max(output.data, 1)
total += label.size(0)
correct += (predicted == label).sum().item()
print('Accuracy:', correct / total)
def main():
**# GPU device**
device = 'cuda:0' if torch.cuda.is_available() else 'cpu'
print('Device state:', device)
epochs = 100
batch_size = 66
lr = 0.004
loss_function = nn.NLLLoss()
model = Net().to(device)
optimizer = optim.Adam(model.parameters(), lr=lr)
**# Transform**
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))]
)
**# Data**
trainset = datasets.MNIST(root='MNIST', download=True, train=True, transform=transform)
testset = datasets.MNIST(root='MNIST', download=True, train=False, transform=transform)
trainset_size = int(len(trainset) * 0.8)
validset_size = len(trainset) - trainset_size
trainset, validset = data.random_split(trainset, [trainset_size, validset_size])
trainloader = data.DataLoader(trainset, batch_size=batch_size, shuffle=True)
testloader = data.DataLoader(testset, batch_size=batch_size, shuffle=False)
validloader = data.DataLoader(validset, batch_size=batch_size, shuffle=True)
**# Train**
model = traindata(device, model, epochs, optimizer, loss_function, trainloader, validloader)
**# Test**
test(device, model, testloader)
if __name__ == '__main__':
main()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到对列车数据应用了提前停车。
PyTorch early stopping example
PyTorch 提前停止调度程序
在本节中，我们将了解 python 中的 PyTorch 提前停止调度器工作方式。
- PyTorch 早期停止用于防止神经网络在训练数据时过拟合。
- 如果损失止损点在训练止损点的某些时期减少，则提前停止调度程序会跟踪验证损失。
代码:
在下面的代码中，我们将导入一些库，从中我们可以使用提前停止调度来训练和验证数据。
- train dataset = PDS . read _ CSV(' train . CSV '，dtype = np.float32) 用于加载训练数据集。
- test dataset = PDS . read _ CSV(' test . CSV '，dtype = np.float32) 用于加载测试数据集。
- features numpy = train dataset . loc[:，train_dataset.columns！= "label"]。values/255 用于归一化数据。
- featurestrain，featurestest，targetstrain，targets test = train _ test _ split(features numpy，targetsnumpy，test_size = 0.2，random_state = 42) 用于分割训练和测试数据集。
- train _ loader = torch . utils . data . data loader(dataset = train _ dataset，batch_size=batch_size，shuffle=True) 用于加载列车数据。
self . layers _ dim = layers _ dim用于获取隐藏层数。- 误差= nn。CrossEntropyLoss() 用于计算交叉熵损失。
- images = images.view(-1，seq_dim，inputs_dim) 用于调整图像的大小。
- 预测= torch.max(outputs.data，1) 用于获得最大值的预测。
total += labels.size(0)用于获取标签总数。
import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision.datasets as dsets
import argparse
import numpy as num
import pandas as pds
from sklearn.model_selection import train_test_split
from torch.autograd import Variable
traindataset = pds.read_csv('train.csv',dtype = np.float32)
testdataset = pds.read_csv('test.csv',dtype = np.float32)
targetsnumpy = traindataset.label.values
featuresnumpy = traindataset.loc[:,train_dataset.columns != "label"].values/255
featurestrain, featurestest, targetstrain, targetstest = train_test_split(featuresnumpy,
targetsnumpy,
test_size = 0.2,
random_state = 42)
**# create feature and targets tensor for train set**
featuresTrain = torch.from_numpy(featurestrain)
targetsTrain = torch.from_numpy(targetstrain).type(torch.LongTensor)
**# create feature and targets tensor for test set.**
featuresTest = torch.from_numpy(featurestest)
targetsTest = torch.from_numpy(targetstest).type(torch.LongTensor)
**# batch_size, epoch and iteration**
batch_size = 100
n_iters = 10000
num_epochs = n_iters / (len(featurestrain) / batch_size)
num_epochs = int(num_epochs)
**# Pytorch train and test sets**
train = torch.utils.data.TensorDataset(featuresTrain,targetsTrain)
test = torch.utils.data.TensorDataset(featuresTest,targetsTest)
**# data loader**
train_loader = torch.utils.data.DataLoader(train, batch_size = batch_size, shuffle = False)
test_loader = torch.utils.data.DataLoader(test, batch_size = batch_size, shuffle = False)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=batch_size,
shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
batch_size=batch_size,
shuffle=False)
**# Create RNN Model**
class RnnModel(nn.Module):
def __init__(self, inputs_dim, hidden_dim, layers_dim, outputs_dim):
super(RnnModel, self).__init__()
**# Hidden dimensions**
self.hidden_dim = hidden_dim
self.layers_dim = layers_dim
self.rnn = nn.RNN(inputs_dim, hidden_dim, layers_dim, batch_first=True, nonlinearity='tanh')
self.fc = nn.Linear(hidden_dim, outputs_dim)
def forward(self, X):
h = torch.zeros(self.layers_dim, x.size(0), self.hidden_dim).requires_grad_()
outs, hn = self.rnn(X, h.detach())
outs = self.fc(outs[:, -1, :])
return outs
**# batch_size, epoch and iteration**
batchsize = 100
niters = 3000
num_epochs = niters / (len(featurestrain) / batchsize)
num_epochs = int(num_epochs)
train = torch.utils.data.TensorDataset(featuresTrain,targetsTrain)
test = torch.utils.data.TensorDataset(featuresTest,targetsTest)
**# data loader**
train_loader = torch.utils.data.DataLoader(train, batch_size = batch_size, shuffle = False)
test_loader = torch.utils.data.DataLoader(test, batch_size = batch_size, shuffle = False)
**# Create RNN**
inputs_dim = 28
hidden_dim = 100
layers_dim = 5
outputs_dim = 12
models = RnnModel(inputs_dim, hidden_dim, layers_dim, outputs_dim)
error = nn.CrossEntropyLoss()
**# SGD Optimizer**
learning_rate = 0.07
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
seq_dim = 28
loss_list = []
iteration_list = []
accuracy_list = []
count = 0
min_val_loss = num.Inf
val_array = []
correct = 0
iter = 0
count = 0
iter_array = []
loss_array = []
total = 0
accuracy_array = []
n_epochs_stop = 6
epochs_no_improve = 0
early_stop = False
for epoch in range(num_epochs):
val_loss = 0
for i, (images, labels) in enumerate(train_loader):
train = Variable(images.view(-1, seq_dim, inputs_dim))
labels = Variable(labels )
**# Clear gradients**
optimizer.zero_grad()
**# Forward propagation**
outputs = model(train)
loss = error(outputs, labels)
**# Calculating gradients**
loss.backward()
**# Update parameters**
optimizer.step()
val_loss += loss
val_loss = val_loss / len(train_loader)
# If the validation loss is at a minimum
if val_loss < min_val_loss
epochs_no_improve = 0
min_val_loss = val_loss
else:
epochs_no_improve += 1
iter += 1
if epoch > 5 and epochs_no_improve == n_epochs_stop:
print('Early stopping!' )
early_stop = True
break
else:
continue
break
if iter % 336 == 0:
**# Calculate Accuracy **
correct = 0
total = 0
**# Check early stopping condition**
if early_stop:
print("Stopped")
break
for images, labels in test_loader:
images = images.view(-1, seq_dim, inputs_dim)
outputs = model(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum()
accuracy = 100 * correct / total
** #Print Loss**
count = count +1
if iter % 336 == 0 and count % 100 == 0 :
iter_array.append(iter)
loss_array.append(loss.item())
accuracy_array.append(accuracy.item())
print('Epoch: {}. Iteration: {}. loss: {}. accuracy: {}, count: {}'.format(epoch,iter, loss.item(),accuracy.item(),count))
输出:
在下面的输出中，我们可以看到早期停止机制防止了神经网络的过度拟合。
PyTorch early stopping scheduler
PyTorch 闪电提前停止
在本节中，我们将了解 python 中的 PyTorch lightning 如何提前停止。
PyTorch lightning early stopping 用于提前停止一个历元，以避免在训练数据集上过度拟合。
代码:
在下面的代码中，我们将导入一些库，我们可以从这些库中尽早停止纪元，以避免过拟合。
torch.nn.Linear()用于在输入和输出的帮助下创建前馈网络。torch.relu()用作激活功能。F.cross_entropy()用于计算两个概率分布之间的差异。- train dataset = MNIST(PATH _ DATASETS，train =真，download =真，transform =变换。ToTensor()) 用于创建训练数据集。
- train loader = data loader(train dataset，batch_size=BATCHSIZE) 用于加载列车数据。
- trainer.fit(mnistmodel，train_loader) 用于拟合训练数据。
import os
import torch
from pytorch_lightning import LightningModule, Trainer
from torch import nn
from torch.nn import functional as f
from torch.utils.data import DataLoader, random_split
from torchmetrics import Accuracy
from torchvision import transforms
from torchvision.datasets import MNIST
PATHDATASET = os.environ.get("PATH_DATASETS", ".")
AVAILGPUS = min(1, torch.cuda.device_count())
BATCHSIZE = 250 if AVAILGPUS else 60
class MNISTModel(LightningModule):
def __init__(self):
super().__init__()
self.l1 = torch.nn.Linear(28 * 28, 10)
def forward(self, X):
return torch.relu(self.l1(X.view(X.size(0), -1)))
def training_step(self, batch, batch_nb):
X, y = batch
loss = F.cross_entropy(self(X), y)
return loss
def configure_optimizers(self):
return torch.optim.Adam(self.parameters(), lr=0.02)
# Init our model
mnistmodel = MNISTModel()
# Init DataLoader from MNIST Dataset
traindataset = MNIST(PATH_DATASETS, train=True, download=True, transform=transforms.ToTensor())
trainloader = DataLoader(traindataset, batch_size=BATCHSIZE)
# Initialize a trainer
trainer = Trainer(
gpus=AVAILGPUS,
max_epochs=3,
progress_bar_refresh_rate=20,
)
# Train the model
trainer.fit(mnistmodel, train_loader)
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到 epoch 被提前停止，以避免在训练数据集上过度拟合。
PyTorch lightening early stopping
阅读: PyTorch nn 线性+例题
PyTorch 点火提前停止
在本节中，我们将学习 python 中的 PyTorch ignite 提前停止。
提前停止 ignite 被定义为一个过程，该过程可用于在给定数量的事件后，当没有改善时停止训练。
语法:
以下语法适用于 ignite 提前停止:
ignite.handler.early_stopping.EarlyStopping(patience,score_function,trainer,min_delta=0.0,cumulative_delta = False)
参数:
- 耐心用于等待事件次数，如果没有改善，则停止训练。
score_function被用作一个函数，它接受一个参数并返回一个分数浮点数。- 训练器用于在没有改善的情况下停止跑步。
min_delta是符合改善条件的分数的最小增量。cumulative_delta如果该值为真，则 min_delta 定义为自上次耐心重置以来的增加，否则它在上次事件后增加，并且 cumulative delta 的默认值为假。
PyTorch 几何提前停车
在本节中，我们将了解 python 中的 PyTorch 几何提前停止是如何工作的。
- PyTorch 几何提前停止被定义为提前停止历元的过程。使用 Early stopping 回调基于度量提前停止。
- 几何与提前停止所使用的方法有关。
代码:
在下面的代码中，我们将导入一些库，这些库的早期停止将使纪元提前停止。
- (trainimage，trainlabel)，(testimage，test label)= Mn ist . load _ data()用于加载数据。
- train image = train image . as type(' float 32 ')/255用于缩小列车图像的像素值。
ytrain = to _ categorial(train label)用于将标签编码为一个二进制的类标签。- 提前停止=回调。early stopping(monitor = " val _ loss "，mode ="min "，patience = 7，restore_best_weights = True) 用于提前停止历元。
models.fit()用于拟合模型。
import keras
from keras.utils.np_utils import to_categorical
from keras.datasets import mnist
(trainimage, trainlabel), (testimage, testlabel)= mnist.load_data()
**# Reshaping data-Adding number of channels**
trainimage = trainimage.reshape((trainimage.shape[0],
trainimage.shape[1],
trainimage.shape[2], 1))
testimage = testimage.reshape((testimage.shape[0],
testimage.shape[1],
testimage.shape[2], 1))
trainimage = trainimage.astype('float32')/255
testimage = testimage.astype('float32')/255
ytrain = to_categorical(trainlabel)
ytest = to_categorical(testlabel)
from keras import models
from keras import layers
models = models.Sequential()
models.add(layers.Conv2D(32, (3, 3), activation ="relu",
input_shape =(28, 28, 1)))
models.add(layers.MaxPooling2D(2, 2))
models.add(layers.Conv2D(64, (3, 3), activation ="relu"))
models.add(layers.MaxPooling2D(2, 2))
models.add(layers.Flatten())
models.add(layers.Dense(64, activation ="relu"))
models.add(layers.Dense(10, activation ="softmax"))
models.compile(optimizer ="rmsprop", loss ="categorical_crossentropy",
metrics =['accuracy'])
valimage = trainimage[:10000]
partialimage = trainimage[10000:]
vallabel = ytrain[:10000]
partiallabel = ytrain[10000:]
from keras import callbacks
earlystopping = callbacks.EarlyStopping(monitor ="val_loss",
mode ="min", patience = 7,
restore_best_weights = True)
history = models.fit(partialimage, partiallabel, batch_size = 130,
epochs = 23, validation_data =(valimage, vallabel),
callbacks =[earlystopping])
输出:
在下面的输出中，我们可以看到在早期停止的帮助下，epoch 被更早地停止。
PyTorch geometric early stopping
PyTorch lstm 提前停止
在本节中，我们将学习 python 中的 PyTorch lstm 提前停止。
LSTM 代表长期短期记忆，它是一种用于深度学习领域的人工神经网络架构。
代码:
在下面的代码中，我们将导入一些可以应用提前停止的库。
- nn。Sequential() 用于按顺序运行某一层。
- nn。线性()用于创建前馈网络。
- 定义训练(设备、模型、时期、优化器、损失函数、训练加载器、有效加载器):用于定义训练数据。
optimizer.zero_grad()用于优化零梯度。- current _ loss = validation(model，device，valid_loader，loss_function) 用于计算当前损耗。
- 打印('当前损失:'，current_loss) 用于打印当前损失。
- 转换数据=转换。Compose() 用于转换数据。
- trainloader =数据。DataLoader(trainset，batch_size=batchsize，shuffle=True) 用于加载列车数据。
- 测试加载器=数据。DataLoader(testset，batch_size=batchsize，shuffle=False) 用于加载测试数据。
import torch
import torch.nn as nn
import torch.optim as optimize
import torch.utils.data as data
from torchvision import datasets, transforms
class modelarc(nn.Module):
def __init__(self):
super(modelarc, self).__init__()
self.main = nn.Sequential(
nn.Linear(in_features=784, out_features=128),
nn.ReLU(),
nn.Linear(in_features=128, out_features=64),
nn.ReLU(),
nn.Linear(in_features=64, out_features=10),
nn.LogSoftmax(dim=1)
)
def forward(self, Input):
return self.main(Input)
def train(device, model, epochs, optimizer, loss_function, train_loader, valid_loader):
the_last_loss = 100
patience = 2
trigger_times = 0
for epoch in range(1, epochs+1):
model.train()
for times, data in enumerate(train_loader, 1):
inputs = data[0].to(device)
labels = data[1].to(device)
optimizer.zero_grad()
outputs = model(inputs.view(inputs.shape[0], -1))
loss = loss_function(outputs, labels)
loss.backward()
optimizer.step()
if times % 100 == 0 or times == len(train_loader):
print('[{}/{}, {}/{}] loss: {:.6}'.format(epoch, epochs, times, len(train_loader), loss.item()))
current_loss = validation(model, device, valid_loader, loss_function)
print('The Current Loss:', current_loss)
if current_loss > the_last_loss:
trigger_times += 1
print('Trigger Times:', trigger_times)
if trigger_times >= patience:
print('Early Stopping!\nStart to test process.')
return model
else:
print('Trigger Times: 0')
trigger_times = 0
the_last_loss = current_loss
return model
def validation(model, device, valid_loader, loss_function):
model.eval()
totalloss = 0
with torch.no_grad():
for data in valid_loader:
input = data[0].to(device)
label = data[1].to(device)
outputs = model(input.view(input.shape[0], -1))
loss = loss_function(outputs, label)
totalloss += loss.item()
return totalloss / len(valid_loader)
def test(device, model, test_loader):
model.eval()
total = 0
correct = 0
with torch.no_grad():
for data in test_loader:
input = data[0].to(device)
label = data[1].to(device)
outputs = model(input.view(input.shape[0], -1))
_, predicted = torch.max(outputs.data, 1)
total += label.size(0)
correct += (predicted == label).sum().item()
print('ModelAccuracy:', correct / total)
def main():
device = 'cpu'
print('Device state:', device)
epochs = 60
batchsize = 44
lr = 0.002
loss_function = nn.NLLLoss()
model = modelarc().to(device)
optimizer = optimize.Adam(model.parameters(), lr=lr)
transformdata = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))]
)
trainset = datasets.MNIST(root='MNIST', download=True, train=True, transform=transformdata)
testset = datasets.MNIST(root='MNIST', download=True, train=False, transform=transformdata)
trainsetsize = int(len(trainset) * 0.6)
validsetsize = len(trainset) - trainsetsize
trainset, validset = data.random_split(trainset, [trainsetsize, validsetsize])
trainloader = data.DataLoader(trainset, batch_size=batchsize, shuffle=True)
testloader = data.DataLoader(testset, batch_size=batchsize, shuffle=False)
validloader = data.DataLoader(validset, batch_size=batchsize, shuffle=True)
model = train(device, model, epochs, optimizer, loss_function, trainloader, validloader)
test(device, model, testloader)
if __name__ == '__main__':
main()
输出:
运行上面的代码后，我们得到下面的输出，从中我们可以看到早期停止是为了避免过度拟合。
PyTorch lstm early stopping
PyTorch 提前停止回调
在本节中，我们将了解 PyTorch 早期停止回调在 python 中是如何工作的。
回调定义为一个过程，允许我们确定要监控的绩效，以便结束培训。
语法:
以下是 PyTorch 回调的语法:
pytorch_lightning.callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=0, verbose=0, mode='auto', baseline=None, restore_best_weights=False)
参数:
monitor用于指定该功能可以监控的值。该值可以是验证损失或验证准确性。- 模式用于改变监视器应观察的数量。
min_delta是为一些变化设置最小值。- 耐心定义为训练的历元数。
verboseverbose 定义为整数值。restore_best_weights如果值为真，则恢复权重。restore_best_weight 的默认值为 false。
PyTorch 验证提前停止
在本节中，我们将了解 python 中 PyTorch 验证的早期停止。
早期停止被定义为避免在训练数据集上过度拟合以及跟踪验证损失的过程。
代码:
在下面的代码中，我们将导入一些库，从中我们可以验证早期停止。
- (trainimages，trainlabels)，(testimages，test labels)= Mn ist . load _ data()用于加载数据。
- train images = train images . shape((train images . shape[0]，trainimages.shape[1]，trainimages.shape[2]，1)) 用于重组数据-增加通道数。
- train images = train images . as type(' float 32 ')/255用于缩小列车图像的像素值。
- test images = test images . as type(' float 32 ')/255用于缩小测试图像的像素图像。
- 提前停止=回调。EarlyStopping() 用于回调提前停止，避免过拟合。
data = models.fit()用于拟合模型。
import keras
from keras.utils.np_utils import to_categorical
from keras.datasets import mnist
(trainimages, trainlabels), (testimages, testlabels)= mnist.load_data()
trainimages = trainimages.reshape((trainimages.shape[0],
trainimages.shape[1],
trainimages.shape[2], 1))
testimages = testimages.reshape((testimages.shape[0],
testimages.shape[1],
testimages.shape[2], 1))
trainimages = trainimages.astype('float32')/255
testimages = testimages.astype('float32')/255
ytrains = to_categorical(trainlabels)
ytests = to_categorical(testlabels)
from keras import models
from keras import layers
models = models.Sequential()
models.add(layers.Conv2D(30, (3, 3), activation ="relu",
input_shape =(28, 28, 1)))
models.add(layers.MaxPooling2D(2, 2))
models.add(layers.Conv2D(66, (3, 3), activation ="relu"))
models.add(layers.MaxPooling2D(2, 2))
models.add(layers.Flatten())
models.add(layers.Dense(66, activation ="relu"))
models.add(layers.Dense(10, activation ="softmax"))
models.compile(optimizer ="rmsprop", loss ="categorical_crossentropy",
metrics =['accuracy'])
validationimage = trainimages[:999]
partialimage = trainimages[999:]
validationlabel = ytrains[:999]
partiallabel = ytrains[999:]
from keras import callbacks
earlystopping = callbacks.EarlyStopping(monitor ="val_loss",
mode ="min", patience = 7,
restore_best_weights = True)
data = models.fit(partialimage, partiallabel, batch_size = 100,
epochs = 15, validation_data =(validationimage, validationlabel),
callbacks =[earlystopping])
输出:
运行上面的代码后，我们得到下面的输出，从中我们可以看到，早期停止可以避免过度拟合，并保持验证损失的跟踪。
PyTorch Validation early stopping
另外，再看看一些 PyTorch 教程。
因此，在本教程中，我们讨论了 PyTorch 提前停止,我们还讨论了与它的实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch 提前停止
- PyTorch 提前停止停止示例
- PyTorch 提前停止调度程序
- PyTorch 闪电提前停止
- PyTorch 点火提前停止
- PyTorch 几何提前停止
- PyTorch lstm 提前停止
- PyTorch 提前停止回调
- PyTorch 验证提前停止
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
创建 PyTorch 空张量
tensor.empty() 函数返回填充了未初始化数据的张量。张量形状是由称为大小的变量定义的。详细来说，我们将在 Python 中使用 PyTorch 讨论空张量。
此外，我们将涵盖与 PyTorch 空张量相关的不同例子。我们将讨论这些话题。
- 什么是 PyTorch 空张量
- PyTorch 空张量示例
- 如何创建 PyTorch 空张量追加
- PyTorch 空张量检查
- 如何使用 contate 创建 pytorch 空张量
- 如何创建 PyTorch 空张量列表
目录
PyTorch 空张量
在这一节中，我们将学习 python 中的 PyTorch 空张量。
tensor.empty() 函数返回填充了未初始化数据的张量，张量形状由变量参数 size 定义。
语法:
PyTorch 空张量的语法是:
torch.empty(size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False, memory_format=torch.contiguous_format)
参数:
以下是 PyTorch 空张量的参数:
- size: Size 是定义输出张量形状的整数序列。
- out:out 是定义输出张量的参数。
- dtype: 类型是返回张量的所需数据类型，dtype 的默认值为无。
- 布局: 布局被定义为返回张量的期望布局。布局的默认值是 【火炬】 。
- 设备: 设备定义为返回张量的期望设备，默认值为无。
- requires _ grad:requires _ grad 为参数。如果签名应该记录对返回张量的操作。requires_grad 的默认值为 False。
- pin_memory:pin _ memory 是一个参数，定义一个集合，返回的张量是否会被分配到 pinned 内存中，只对 CPU 张量有效，pin _ memory 的默认值为 False。
- memory _ format:memory _ format 定义为返回张量的期望内存格式，
memory_format的默认值是一个*torch . contiguous _ format*。
这就是我们借助 torch.empty() 函数对 PyTorch 空张量的理解。
PyTorch 空张量示例
在这一节中，我们将学习如何借助 python 中的示例来实现 Pytorch 空张量。
在 PyTorch 空张量示例中，我们使用了 torch.empty()，它可以返回带有封闭数据的张量包，张量的形状由名为 size 的变量参数定义。
代码:
在下面的代码中，我们将导入火炬库作为导入火炬。
- e=torch.empty((3，4)，dtype=torch.int64): 这里我们描述 e 变量，调用 empty()函数。
- f= torch.empty((5，6)，dtype=torch.int64): 这里我们调用的是 empty()函数。
- print("空张量值 e:"，e) 用于借助 print()函数打印空张量 e 值。
# Import library
import torch
# Calling the empty() function
e=torch.empty((3,4), dtype=torch.int64)
f= torch.empty((5,6), dtype=torch.int64)
# Print the empty tensor values
print("The empty tensor value e :", e)
print("The empty tensor value f :", f)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 空张量值被打印在屏幕上。
Pytorch empty tensor example
这样，我们借助一个使用 torch.empty() 函数的例子来理解 Pytorch 空张量。
PyTorch 空张量追加
在这一节中，我们将学习 python 中的 PyTorch 空张量 append 。
- 在继续之前，我们应该有一些关于追加的知识。
- Append 定义为可以在书面文档的末尾添加内容的操作。
- 这里我们添加了一个空张量，它可以返回带有封闭数据的张量包。
代码:
在下面的代码中，我们将导入 torch 模块作为导入 torch。
- a= torch.empty(2): 这里我们用变量 a 调用 torch.empty()函数。
- print("a "，a) 用于通过 print()函数打印 a 的值。
- b= torch.empty(4): 这里我们用变量 b 调用 torch.empty()函数。
# Import torch
import torch
# Calling the empty() function a
a= torch.empty(2)
print("a", a)
torch.Tensor([0.])
# Calling the empty() function b
b= torch.empty(4)
print("b", b)
torch.Tensor([0., 0., 0.])
# Calling the empty() function c
c= torch.empty(4,5)
print("c", c)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 空张量值被打印在屏幕上。
PyTorch empty tensor append
这样，我们借助 torch.empty()函数理解了 PyTorch 空张量 append。
PyTorch 空张量检查
在本节中，我们将学习 python 中的 PyTorch 空张量检查。
检查是按顺序研究或测试某物，以确信它是安全的或正确的，并处于良好状态。
代码:
在下面的代码中，我们将导入 torch 库来检查 python 中的空张量。
- f = torch.empty([5，6]): 这里我们调用的是 empty 函数，将结果张量存储在 f 中。
- print("f = "，f) 用于通过 print()函数打印 f 的值。
- g = torch.empty([4，5]): 这里我们调用的是 empty()函数，将得到的张量存储在 g 中。
# Importing the torch library
import torch
# Calling the empty function and storing the resulting tensor in 'f'
f = torch.empty([5, 6])
print("f = ", f)
# Calling the empty function and storing the resulting tensor in 'g'
g = torch.empty([4, 5])
print("g = ", g)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 空张量检查值被打印在屏幕上。
PyTorch empty tensor check
这就是我们如何理解如何在 python 中检查 PyTorch 空张量。
阅读: PyTorch Conv1d
PyTorch 空张量串联
在这一节中，我们将学习 python 中的 PyTorch 空张量 concate 。
在继续之前，我们应该有一些关于 PyTorch 空张量拼接的知识。
PyTorch 空张量连接函数用于通过使用 torch.cat() 函数将两个或更多张量与一行或一列连接起来。
代码:
在下面的代码中，我们将导入火炬库作为导入火炬。
- b = torch.empty(1，2): 这里我们调用的是 torch.empty()函数。
- b = torch.cat([b，a]，dim=0): 这里我们调用的是 torch.cat()函数。
print(b)用于通过 print()函数打印变量 b 的值。
# Import library
import torch
# Calling the empty() function
b = torch.empty(1,2)
for x in range(3):
a = torch.FloatTensor([[2,3],[5,6]])
# Calling the torch.cat() function
b = torch.cat([b, a], dim=0)
# Print the value of b
print(b)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 空张量串联值被打印在屏幕上。
PyTorch empty tensor concate
这就是我们如何借助 torch.empty() 和 torch.cat()函数来理解 PyTorch 空张量 concate 的。
阅读: PyTorch 超参数调谐
PyTorch 空张量列表
在这一节，我们将学习 python 中的 PyTorch 空张量列表。
该列表被定义为一个接一个打印的名称和数字的序列。
PyTorch 空张量列表被定义为可以通过使用 torch.empty()函数返回带有闭合数据的张量包的列表。
代码:
在下面的代码中，我们将导入火炬库作为导入火炬。
- a = torch.empty((5，6)，dtype=torch.int64): 这里我们调用的是 torch.empty()函数。
- print("变量 a 的空张量列表的值:"，a) 用于借助 print()函数打印变量 a 的空张量列表的值。
# Import library
import torch
# Calling the empty() function of a
a = torch.empty((5,6), dtype=torch.int64)
# Calling the empty() function of b
b = torch.empty((7,8,9), dtype=torch.int64)
# Print the value if variable a
print("The value of empty tensor list of variable a:", a)
# Print the value if variable b
print("The value of empty tensor list of variable b:", b)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 空张量列表值被打印在屏幕上。
PyTorch empty tensor list
您可能也喜欢阅读下面的 Python PyTorch 教程。
- PyTorch 线性回归
- py torch nn s 形教程
- PyTorch 栈教程
- 如何使用 PyTorch Polar
- 【numpy 指针为张量
- PyTorch 激活功能
- PyTorch MNIST 教程
因此，在本教程中，我们讨论了 PyTorch 空张量，也涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- 什么是 PyTorch 空张量
- PyTorch 空张量示例
- 如何创建 PyTorch 空张量追加
- PyTorch 空张量检查
- 如何使用 contate 创建 pytorch 空张量
- 如何创建 PyTorch 空张量列表
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch 扁平化+ 8 个示例
*PyTorch Flatten* 方法携带实数和复数输入张量。 torch.flatten() 方法用于通过整形将张量展平为一维张量。详细来说，我们将讨论在 python 中使用 PyTorch 的 flatten()方法。
此外，我们还将介绍与 *PyTorch flatten()* 函数相关的不同示例。我们将讨论这些话题。
- PyTorch 展平是什么
- PyTorch 展平示例
- PyTorch 展平层
- PyTorch 展平张量列表
- PyTorch 展平参数
- 如何用 2D 元素创建一个张量并展平这个向量
- 如何用 3D 元素创建一个张量并展平这个向量
目录
- 什么是 PyTorch 展平
- PyTorch 展平示例
- PyTorch 展平图层
- PyTorch 展平张量列表
- PyTorch 展平参数
- 如何用 2D 元素创建一个张量并展平这个向量
- 如何用 3D 元素创建一个张量并展平这个向量
什么是 PyTorch 展平
在这一节中，我们将学习 python 中的 PyTorch flatten。
torch.flatten() 方法用于通过整形将张量展平为一维张量。
PyTorch 展平方法携带实数和复合值输入张量。它获取一个 torch 张量作为输入，并返回一个被展平为一维的 torch 张量。
语法:
PyTorch flatten 的语法:
torch.flatten(input, start_dim=0, end_dim=-1)
参数:
以下是 PyTorch 展平的参数
- 输入:用作输入张量。
- start_dim: 作为第一个要展平的 dim。
- end_dim: 作为最后一个要展平的 dim。
因此，有了这个，我们详细了解了 PyTorch 展平。
阅读: PyTorch 预训练模型
PyTorch 展平示例
在这一节中，我们将借助 python 中的一个例子来学习如何实现 PyTorch flatten。
PyTorch 展平方法携带实数和复合值输入张量。它获取一个 torch 张量作为输入，并返回一个被展平为一维的 torch 张量。它包含两个参数 start_dim 和 end_dim。
代码:
在下面的代码中，我们将首先导入 torch 库，如 import torch。
f = torch.tensor([[[2，4]，[6，8]]，[[10，12]，[14，16]])通过使用 torch.tensor()函数来描述变量。
torch.flatten(f):这里我们使用了 torch.flatten()函数。
torch.flatten(f，start_dim=1)用作 flatten()函数，在这个函数中，我们使用了一些参数。
# Import library
import torch
# Describe the variable by using torch.tensor() function
f = torch.tensor([[[2, 4],
[6, 8]],
[[10, 12],
[14, 16]]])
# Using the torch.flatten() method
torch.flatten(f)
torch.tensor([2, 4, 6, 8, 10, 12, 14, 16])
torch.flatten(f, start_dim=1)
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到 PyTorch Flatten 值打印在屏幕上。
PyTorch Flatten example
这就是我们如何借助一个例子来理解 PyTorch 展平。
PyTorch 展平图层
在这一节中，我们将学习 python 中的 PyTorch 展平层。
PyTorch Flatten 用于将具有不同维度的任何张量层整形为单一维度。
torch.flatten() 函数用于通过整形将张量展平为一维张量。
代码:
在下面的代码中，我们将首先导入 torch 库，如 import torch。
- f = torch.tensor([[[2，4，6]，[8，10，12]]，[[14，16，18]，[20，22，24]])这里我们用 torch.tensor()函数来描述 f 变量。
flatten _ tens = torch . flatten(f)这里我们用 end_dims 来描述展平上面的张量。- print("Flatten tensor:\n "，flatten_tens) 用于打印展平张量。
# Import Library
import torch
f = torch.tensor([[[2, 4, 6],
[8, 10, 12]],
[[14, 16, 18],
[20, 22, 24]]])
print("Tensor:\n", f)
print("Size of Tensor:", f.size())
# Describe the flatten the above tensor by using end_dims
flatten_tens = torch.flatten(f)
flatten_tens1 = torch.flatten(f, end_dim=0)
flatten_tens2 = torch.flatten(f, end_dim=1)
flatten_tens3 = torch.flatten(f, end_dim=2)
# print the flatten tensors
print("Flatten tensor:\n", flatten_tens)
print("Flatten tensor (end_dim=0):\n", flatten_tens1)
print("Flatten tensor (end_dim=1):\n", flatten_tens2)
print("Flatten tensor (end_dim=2):\n", flatten_tens3)
输出:
在下面的代码中，你可以看到 PyTorch 展平图层在 torch.flatten() 函数的帮助下被重新整形。
PyTorch Flatten layer
这样，我们就明白了如何借助 torch.flatten() 来重塑张量层。
阅读: PyTorch nn 线性+例题
PyTorch 展平张量列表
在这一节中，我们将学习 python 中张量的 PyTorch 展平列表。
PyTorch 通过将张量输入整形为一维张量来展平张量输入列表。输入、start_dim 和 end_dims 在 torch.flatten()函数中传递。以 start_dim 开始并以 end_dim 结束的尺寸被展平。
代码:
在下面的代码中，我们将首先导入 torch 库，如 import torch。
- f = torch.tensor([[[31，30]，[29，28]]，[[27，26]，[25，24]])用于使用 torch.tensor()函数描述变量。
torch.flatten(f)这里我们使用的是 torch.flatten()函数。- i = torch.randn(4，17，18，18) 用于通过使用 torch.randn()函数来描述变量。
print(res)用于使用print()功能打印结果。
# Import Library
impo# Import library
import torch
import torch.nn as nn
f = torch.tensor([[[31, 30],
[29, 28]],
[[27, 26],
[25, 24]]])
# Using torch.flatten()
torch.flatten(f)
torch.tensor([31, 30, 29, 28, 27, 26, 25, 24])
torch.flatten(f, start_dim=1)
# Describing the variable by using torch.randn()
i = torch.randn(4, 17, 18, 18)
j = nn.Sequential(
nn.Conv2d(17, 4, 18, 56, 4),
nn.Flatten()
)
res = j(i)
print(res)
res.size()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 py torch tensor 值的 Flatten 列表打印在屏幕上。
PyTorch flatten list of tensors
这就是我们如何理解 PyTorch 在 python 中展平张量列表。
PyTorch 展平参数
在本节中，我们将学习 python 中的 PyTorch 展平参数。
这里我们使用了 torch.flatten()函数，在这个函数中，我们使用了一些参数。第一个参数是 input，第二个参数是 start_sim，最后一个参数是 end_dim。
以 start_dim 开始并以 end_dim 结束的尺寸被展平。
代码:
在下面的代码中，我们将首先导入 torch 库，如 import torch。
- f = torch.empty(4，4，5，5)。random_(30) 这里我们用 torch.empty()函数来描述 f 变量。
- print("Size of tensor:"，f.size()) 用于借助 print()函数打印张量的大小。
- ftens = torch.flatten(f，start_dim=2，end_dim=3):这里我们用 strat_dim 和 end_dim 将上面的张量展平。
- print(" Flatten tensor(start _ dim = 2，end_dim=3):\n "，ftens) 用于打印展平张量。
# Importing Library
import torch
# Describing the variable
f = torch.empty(4,4,5,5).random_(30)
# Printing the size of the tensor
print("Tensor:\n", f)
print("Size of tensor:", f.size())
# Here we are flatten the above tensor using start_dim and end_dim
ftens = torch.flatten(f, start_dim=2, end_dim=3)
# printing the flatten tensors
print("Flatten tensor (start_dim=2,end_dim=3):\n", ftens)
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到 PyTorch Flatten 参数值打印在屏幕上。
PyTorch Flatten parameters
这就是我们对 torch.flatten()函数中使用的 PyTorch Flatten 参数的理解。
如何用 2D 元素创建一个张量并展平这个向量
在这一节中，我们将学习如何用二维元素创建一个张量，并在 python 中展平这个向量。
这里我们使用 flatten()函数，该函数用于将 N 维张量展平为一维张量。
代码:
在下面的代码中，我们将首先导入 torch 库，如 import torch。
- f = torch.tensor([[2，4，6，8，10，12，14，16，18，20]，[2，4，6，8，10，12，14，16，18，20]]) 用于创建一个有 10 个元素的二维张量。
print(f)用于显示实际张量。print(torch.flatten(f)):这里我们用 flatten()函数来谄媚一个张量。
# import torch module
import torch
# Here we creating an 2 D tensor with 10 elements each
f = torch.tensor([[2,4,6,8,10,12,14,16,18,20],
[2,4,6,8,10,12,14,16,18,20]])
# Showing the actual tensor
print(f)
# Here we are flattening a tensor with flatten() function
print(torch.flatten(f))
输出:
运行上面的代码后，我们得到了下面的输出，其中我们可以看到，二维张量创建了 10 个元素值打印在屏幕上。
How to create a tensor with 2D elements and flatten this vector
有了这个，我们明白了如何用 2D 元素创建一个张量，并展平这个向量。
阅读: PyTorch 全连接层
如何用 3D 元素创建一个张量并展平这个向量
在这一节中，我们将学习如何用 3D 元素创建一个张量，并在 python 中展平这个向量。
这里我们使用 flatten()函数，该函数用于将 N 维张量展平为一维张量，并创建一个包含三维元素的张量，然后展平向量。
代码:
在下面的代码中，我们将首先导入 torch 库，如 import torch。
- f = torch . tensor([[2，4，6，8，10，12，14，16，18，20]，[2，4，6，8，10，12，16，18，20]，[2，4，6，8，12，14，16，18，20]，[2，4，6，8，10，12，14，16，18，20]])]
print(f)用于显示实际张量。- print(torch.flatten(f)): 这里我们用 flatten()函数展平一个张量。
# import torch module
import torch
# create an 3 D tensor with 10 elements each
f = torch.tensor([[[2,4,6,8,10,12,14,16,18,20],
[2,4,6,8,10,12,14,16,18,20]],
[[2,4,6,8,10,12,14,16,18,20],
[2,4,6,8,10,12,14,16,18,20]]])
# Showing the actual tensor
print(f)
# Here we are flatten a tensor with flatten() function
print(torch.flatten(f))
输出:
在下面的输出中，我们可以看到 3d 张量是用 10 个元素值打印在屏幕上创建的。
How to create a tensor with 3D elements and flatten this vector
因此，有了这个，我们明白了如何用 3D 元素创建一个张量，并展平这个向量。
另外，看看更多使用 Python 的 PyTorch 教程。
因此，在本教程中，我们讨论了 PyTorch Flatten ，并且我们还讨论了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch 展平是什么
- PyTorch 展平示例
- PyTorch 展平层
- PyTorch 展平张量列表
- PyTorch 展平参数
- 如何用 2D 元素创建一个张量并展平这个向量
- 如何用 3D 元素创建一个张量并展平这个向量
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何使用 PyTorch Full()函数
*py torch torch . full()*函数定义为创建一个用 fill_value 填充的大小的张量。详细来说，我们将讨论 Python 中使用 PyTorch 的 full() 函数。
此外，我们将介绍与 PyTorch full()函数相关的不同示例。我们将讨论这些话题。
- 什么是 PyTorch full()函数
- PyTorch full()函数示例
- PyTorch torch.new_full()函数是什么
- PyTorch torch.full_like()函数是什么
- 如何使用 PyTorch full()函数追加
目录
- 什么是 PyTorch full()函数
- PyTorch full()函数示例
- 什么是 PyTorch torch.new_full()函数
- 什么是 PyTorch torch.full_like()函数
- 如何使用 PyTorch full()函数追加
什么是 PyTorch full()函数
在本节中，我们将学习 python 中的 PyTorch full()函数。
*py torch torch . full()*函数被定义为创建一个用 fill_value 填充的大小的张量，张量 dtype 从 fill_value 中推导出来。
语法:
PyTorch full()函数的语法是:
torch.full(size, fill_value, out=None, dtype=None, layout=torch.strided, device=None, required_grad=False)
参数:
size:size 是一个参数，它定义了一个列表、元组或整数的大小，这些整数定义了输出张量的形状。
- fill_value: 填充值用于填充输出张量。
- out = None:out 是一个被描述为输出张量的参数。
- dtype=None: 类型被定义为返回张量的所需数据类型。dtype 的默认值是 None。
layout=torch.strided定义为返回张量的期望布局，布局的默认值为 torch.strided。device=None定义为返回张量的期望设备。设备的默认值是无。- requires_grad:requires _ grad 定义为一个参数，如果自动签名应该记录对返回张量的操作，requires _ grad 的默认值为 False。
这样，我们借助 torch.full()方法理解了 PyTorch 的全部功能。
阅读: PyTorch Conv3d
PyTorch full()函数示例
在这一节中，我们将借助 python 中的一个例子来学习如何实现 full()函数。
这里我们使用 torch.full()创建一个用 fill_value 填充的大小为大小为的张量。
代码:
在下面的代码中，我们将导入 torch 模块，如 import torch。
- f = torch.full((4，6)，3.141592): 这里我们调用 full()函数，将结果存储在 f 变量中。
- print(" f 的 full()张量值:"，f) 使用 print()函数打印 f 的 full()函数值。
- g = torch.full((3，5)，3.1) 用于描述一个 full()函数，并将结果存储在 g 变量中。
# Importing the torch library
import torch
# Calling the full() function and storing the result tensor in variable f
f = torch.full((4, 6), 3.141592)
# Print the full function tensor
print("The full() function value of f:", f)
# Calling the full() function and storing the result tensor in variable g
g = torch.full((3, 5), 3.1)
# Print the full function tensor
print("The full() function value of g:", g)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch full()函数值被打印在屏幕上。
PyTorch full function example
这就是我们借助 python 中的一个例子来理解 PyTorch full()函数的方法。
阅读: PyTorch 查看教程
什么是 PyTorch torch.new_full()函数
在本节中，我们将学习 python 中的 PyTorch torch.new_full()函数。
torch.new _ full()函数返回用 fill_value 填充的大小为 size 的张量，默认情况下，因为这个设备返回值具有相同的 torch.dtype 和 torch.device。
语法:
PyTorch torch.new_full()函数的语法:
torch.new_full(size, fill_value, dtype=None, device=None, requires_grad=False)
参数:
fill _ value:fill _ value 是描述填充输出张量的数字的参数。
- dtype: 类型定义为返回张量的期望类型，dtype 的默认值为 None。
- 设备:设备被定义为期望类型的返回张量。设备的默认值是无。
requires_grad:requires _ grad 定义为一个参数，如果自动签名应该记录对返回张量的操作，requires _ grad 的默认值为 False。
举例:
在下面的代码中，我们将导入 torch 库，如 import torch。
- ten = torch.ones((4，)，dtype=torch.float64): 这里我们用 torch.ones()函数来描述张量变量。
- a= ten.new_full((5，6)，3.382792): 这里我们调用的是 tensor.new_full()函数。
print(a)用于使用 print()函数在屏幕上打印 torch.new_full()函数值。
# Importing the torch library
import torch
# Describing the variable
ten = torch.ones((4,), dtype=torch.float64)
# Calling the tensor.new_full()
a= ten.new_full((5, 6), 3.382792)
# Print the torch.new_full() value
print(a)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch torch.new_full()函数值被打印在屏幕上。
PyTorch torch.new_full function
这就是我们对 python 中 PyTorch torch.new_full()函数的理解。
阅读: PyTorch 添加尺寸
什么是 PyTorch torch.full_like()函数
在本节中，我们将学习 python 中的 PyTorch torch.full_like()函数。
torch.full _ like()函数返回与用 fill_value 填充的输入大小相同的张量。
语法:
PyTorch torch.full_like()函数的语法:
torch.full_like(input, fill_value, dtype=None, layout=torch.strided, device=None, required_grad=False, memory_format=torch.preserve_format)
参数:
以下是 torch.full _ like()函数的参数:
- 输入:输入是输入的大小将决定输出张量大小的参数。
- fill _ value:fill _ value 定义为填充输出张量的数。
- dtype:dtype 被定义为返回张量的所需数据类型，dtype 的默认值是 None。
- 布局:布局是的一个参数，表示返回张量的期望布局。布局的默认值是无。
- 设备:设备被定义为返回张量的期望设备，缺省值为 None。
- requires_grad:如果自动签名应该记录对返回张量的操作，并且 requires_grad 的默认值为 False，则 requires_grad 被定义为一个参数。
- memory_format:memory _ format 被定义为返回张量所需的内存格式，memory _ format 的默认值是 torch.preserve_format。
这样，我们理解了 python 中的 torch.full _ like()函数。
阅读: Jax Vs PyTorch
如何使用 PyTorch full()函数追加
在本节中，我们将学习如何使用 python 中的 PyTorch full()函数 append 。
在继续之前，我们应该了解一些关于追加的知识。
追加被定义为在书面文档的末尾添加内容的过程。
这里，我们通过使用 torch.full()方法在 PyTorch full 函数中追加整数。
代码:
在下面的代码中，我们将导入 torch 库，如 import torch。
- f = torch.full([5，6]，4.55) 用于应用 full()函数，并将结果张量存储在 f 中。
- print("f = "，f) 用于通过 print()函数打印 f 的值。
- g = torch.full([4，7]，2.5) 用于应用 full()函数，并将结果张量存储在 g 中。
- print("g = "，g) 用于借助 print()函数打印值 g。
# Importing the torch library
import torch
# Applying the full function and storing the resulting tensor in 'f'
f = torch.full([5, 6], 4.55)
# Print the variable f
print("f = ", f)
# Applying the full function and storing the resulting tensor in 'g'
g = torch.full([4, 7], 2.5)
# Print the variable g
print("g = ", g)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch full()函数的 append 值被打印在屏幕上。
PyTorch full function append
这就是我们理解如何使用 PyTorch full()函数 append 的方式。
你可能也喜欢阅读下面的 PyTorch 教程。
- pytorch league relu
- PyTorch 猫功能
- 创建 PyTorch 空张量
- 如何在 PyTorch 中压缩张量
- PyTorch 展平+ 8 个示例
- PyTorch 激活功能
- PyTorch 车型总结
- PyTorch 逻辑回归
因此，在本教程中，我们讨论了 PyTorch full() ，并且我们还讨论了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- 什么是 PyTorch full()函数
- PyTorch full()函数示例
- PyTorch torch.new_full()函数是什么
- PyTorch torch.full_like()函数是什么
- 如何使用 PyTorch full()函数追加
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch 全连接层
在这个 Python 教程中，我们将学习 Python 中的 PyTorch 全连接层，我们还将涵盖与 PyTorch 全连接层相关的不同示例。我们将讨论这些话题。
- PyTorch 全连接层
- PyTorch 全连接层初始化
- PyTorch 全连接层输入大小
- PyTorch cnn 全连接层
- PyTorch 2d 全连接层
- PyTorch 具有 128 个神经元的全连接层
- PyTorch 全连接层，带脱落
- PyTorch 全连接层 relu
目录
- PyTorch 全连接层
- PyTorch 全连接层初始化
- PyTorch 全连接层输入尺寸
- PyTorch CNN 全连接层
- PyTorch 2d 全连通层
- py torch 128 神经元全连接层
- PyTorch 全连接层，带脱落
- PyTorch 全连接层 relu
PyTorch 全连接层
在本节中，我们将学习 Python 中的 PyTorch 全连接层。
线性层也称为全连接层。这一层帮助转换来自前一层的输出的维度。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以转换上一层输出的维度。
- inp = torch.randn(15，9) 作为输入值。
- weght = torch.randn(7，9) 用于生成权重。
- torch.mm(inp，weght.t()) 用作矩阵乘法。
- lay=nn。Linear(in_features=9，out_features=7，bias=False) 用于创建前馈网络。
- lay.weght=nn。参数(weght)用于定义为一个权重。
import torch
import torch.nn as nn
inp = torch.randn(15, 9)
weght = torch.randn(7,9)
torch.mm(inp,weght.t())
lay=nn.Linear(in_features=9,out_features=7,bias=False)
lay.weght=nn.Parameter(weght)
lay.weght
lay(inp)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 完全连接的层显示在屏幕上。
PyTorch fully connected layer
阅读: PyTorch 车型总结
PyTorch 全连接层初始化
在本节中，我们将学习如何在 python 中初始化 PyTorch 全连接层。
线性层用于神经网络的最后一级。它的线性层也称为全连通层。
线性层是初始化的，有助于转换前一层输出的维度。
为此，该模型可以很容易地解释数据值之间的关系。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以初始化完全连接的层。
- nn。Conv2d() 用于对输入应用 2d 卷积。
- nn。Dropout2d() 用于帮助提升特征图之间的独立性。
- self.fc = nn。线性(9218，130) 用作第一个全连接层。
- self.fc1 = nn。线性(130，12) 用作第二个全连接层。
- 打印(nnmodel) 用于打印模型。
import torch as tor
import torch.nn as nn
import torch.nn.functional as fun
class model(nn.Module):
def __init__(self):
super(model, self).__init__()
self.conv = nn.Conv2d(3, 34, 5, 3)
self.conv1 = nn.Conv2d(34, 66, 5, 3)
self.dropout = nn.Dropout2d(0.27)
self.dropout1 = nn.Dropout2d(0.7)
self.fc = nn.Linear(9218, 130)
# Second fully connected layer that outputs our 10 labels
self.fc1 = nn.Linear(130, 12)
nnmodel = model()
print(nnmodel)
输出:
在下面的输出中，我们可以看到完全连接的层正在成功初始化。
PyTorch fully connected layer initialization
阅读: PyTorch 数据加载器+示例
PyTorch 全连接层输入尺寸
在本节中，我们将学习 python 中的 PyTorch 全连接层输入大小。
全连接层将输入乘以一个权重矩阵，并加上一个权重。神经网络的输入是批量大小通道数量身高*体重的类型。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以获得全连接层的输入大小。
- nn。Conv2d() 等待输入的形状为 batch_size、input_channels、input_height、input_width。
- nn。线性()用作前馈神经网络。
print(fc)用于打印完全连接的神经网络。
import torch
import torch.nn as nn
import torch.nn.functional as fun
class fcmodel(nn.Module):
def __init__(self):
super(fcmodel, self).__init__()
self.conv = nn.Conv2d(5, 8, 7)
self.pool = nn.MaxPool2d(2,2)
self.conv1 = nn.Conv2d(8, 18, 7)
self.fc = nn.Linear(16*5*5, 120)
self.fc1 = nn.Linear(140, 86)
self.fc2 = nn.Linear(86, 12)
def forward(self, y):
y = self.pool(fun.relu(self.conv(y)))
y = self.pool(fun.relu(self.conv1(y)))
y = y.view(-1, 16*5*5)
y = fun.relu(self.fc(y))
y = fun.relu(self.fc1(y))
y = self.fc2(y)
return y
fc = fcmodel()
print(fc)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到完全连接的层输入大小被打印在屏幕上。
PyTorch fully connected layer input size
阅读: PyTorch 模型评估+示例
PyTorch CNN 全连接层
在本节中，我们将学习 python 中的 PyTorch CNN 全连接层。
CNN 是解决计算机视觉最流行的方法，例如物体检测。CNN 对等图像中的模式。
线性层用于卷积神经网络的最后一级。它的线性层也称为全连通层。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以创建 cnn 全连接层。
- def forward(self，y) 这里 y 是代表我们的数据。
y = self.conv(y)用于通过 conv 传递数据。y = func.relu(y)用于 y 上的整流线性激活函数- y = func.max_pool2d(y，2) 用于在 y 上运行最大池。
y = self.dropout(y)用于通过 dropout 传递数据。- y = torch.flatten(y，1) 用作 flatten y，start_dim 为 1。
y = self.fc(y)用于通过 fc 传递数据。print (cnn)用于打印 cnn 图层。
import torch
import torch.nn as nn
import torch.nn.functional as func
class cnnfc(nn.Module):
def __init__(self):
super(cnnfc, self).__init__()
self.conv = nn.Conv2d(3, 34, 5, 3)
self.conv1 = nn.Conv2d(34, 66, 5, 3)
self.dropout = nn.Dropout2d(0.30)
self.dropout1 = nn.Dropout2d(0.10)
self.fc = nn.Linear(9218, 130)
self.fc1 = nn.Linear(130, 15)
def forward(self, y):
y = self.conv(y)
y = func.relu(y)
y = self.conv1(y)
y = func.relu(y)
y = func.max_pool2d(y, 2)
y = self.dropout(y)
y = torch.flatten(y, 1)
y = self.fc(y)
y = func.relu(y)
y = self.dropout1(y)
y = self.fc1(y)
cnn = cnnfc()
print (cnn)
输出:
在下面的输出中，我们可以看到 PyTorch cnn 全连接层打印在屏幕上。
PyTorch cnn fully connected layer
PyTorch 2d 全连通层
在本节中，我们将学习 Python 中的 PyTorch 2d 连接层。
2d 全连接图层有助于更改前一图层的输出维度。该模型可以很容易地定义数据值之间的关系。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以初始化 2d 全连接层。
- nn。Conv2d() 用于执行 2d 数据的卷积。
- nn。线性()用于创建一个前馈神经网络。
modl = model()用于初始化模型。print(modl)用于打印模型。
import torch
import torch.nn as nn
import torchvision
import torch.nn.functional as func
import torchvision.transforms as transforms
class model(nn.Module):
def __init__(self):
super(model, self).__init__()
self.conv = nn.Conv2d(in_channels=3, out_channels=34, kernel_size= 7,stride = 3)
self.conv1 = nn.Conv2d(34, 66, 7, 2)
self.fc = nn.Linear(66*22*22, 49)
def forward(self, y):
y = func.relu(self.conv(y))
y = func.relu(self.conv1(y))
y = func.max_pool2d(y, 1)
y = torch.flatten(y, 1)
y = self.fc(y)
out = func.log_softmax(y, dim=1)
return out
# initiating the model
modl = model()
print(modl)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 2d 全连接层打印在屏幕上。
PyTorch 2d fully connected layer
阅读: PyTorch 批量标准化
py torch 128 神经元全连接层
在本节中，我们将学习 python 中具有 128 个神经元的 PyTorch 全连接层。
全连接层被定义为来自一层的所有输入都连接到下一层的每个激活单元的层。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以制作具有 128 个神经元的全连接层。
- self.conv = nn。Conv2d(1，35，(7，7)，padding=0) 用于与 35 个大小为 7 x 7 的特征映射进行卷积，并激活 ReLU。
- self.fc = nn。线性(20 * 74，128)** 用作 128 个神经元的全连接层。
z = self.conv(y)被用作通过 conv 传递数据。z = func.relu(z)用作 z 上的整流线性激活函数- z = func.max_pool2d(z，2) 在 z 上运行最大池。
z = self.dropout(z)数据可以通过 dropout 传递。- z = torch.flatten(z，1) 用 start_dim = 1 展平 z。
cnn = cnnwithneurons()用于初始化模型。
import torch
import torch.nn.functional as func
from torch import nn
class cnnwithneurons(nn.Module):
def __init__(self):
super(cnnwithneurons, self).__init__()
self.conv = nn.Conv2d(1, 35, (7, 7), padding=0)
self.conv1 = nn.Conv2d(35, 20, (5, 5), padding=0)
self.fc = nn.Linear(20 * 7**4, 128)
self.fc1 = nn.Linear(128, 52)
self.fc2 = nn.Linear(52, 12)
def forward(self, z):
z = self.conv(y)
z = func.relu(z)
z = self.conv1(z)
z = func.relu(z)
z = func.max_pool2d(z, 2)
z = self.dropout(z)
z = torch.flatten(z, 1)
z = self.fc(z)
z = func.relu(z)
z = self.dropout1(z)
z = self.fc1(z)
cnn = cnnwithneurons()
print (cnn)
输出:
在下面的输出中，我们可以看到屏幕上打印了具有 128 个神经元的全连接层。
PyTorch fully connected layer with 128 neurons
阅读: PyTorch 负载模型+示例
PyTorch 全连接层，带脱落
在本节中，我们将学习 python 中的 P yTorch 全连接层和 dropout 。
使用丢弃技术去除神经网络，以同时模拟训练大量架构。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以获得带有 dropout 的全连接层。
- self.conv = nn。Conv2d(5，34，5) 等待输入的形状为 batch_size，input_channels，input_height，input_width。
- nn。线性()用于创建前馈神经网络。
- self.dropout = nn。【T1(0.27)】用于定义神经元要脱落的比例。
model =dropoutmodel()用于初始化模型。- 打印(模型)用于打印模型。
import torch
from torch import nn
import torch.nn.functional as func
from torch import nn
class dropoutmodel(nn.Module):
def __init__(self, input_shape=(3,32,32)):
super(dropoutmodel, self).__init__()
self.conv = nn.Conv2d(5, 34, 5)
self.conv1 = nn.Conv2d(34, 66, 5)
self.conv2 = nn.Conv2d(66, 130, 5)
self.pool = nn.MaxPool2d(2,2)
self.fc = nn.Linear(20 * 9**4, 218)
self.fc1 = nn.Linear(218, 10)
# Define proportion or neurons to dropout
self.dropout = nn.Dropout(0.27)
def forward(self, z):
z = self._forward_features(z)
z = z.view(z.size(0), -1)
z = self.dropout(z)
z = func.relu(self.fc1(z))
# Apply dropout
z = self.dropout(z)
z = self.fc2(z)
return z
model =dropoutmodel()
print(model)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 完全连接的 dropout 打印在屏幕上。
PyTorch fully connected layer dropout
阅读: PyTorch nn 线性+例题
PyTorch 全连接层 relu
在本节中，我们将学习 python 中的 PyTorch 全连接层 relu 。
在前进之前，我们应该对 relu 有一些了解。ReLu 代表校正线性激活函数。
它也被称为用于多线性神经网络的非线性激活函数。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以得到完全连接的层 relu。
- 【fcrmodel 类(nn。模块用于定义网络类。
- 超级()。init() 用于从超类调用构造函数。
- nn。线性()用于创建一个前馈神经网络。
func.relu(self.fc1(z))用于定义正向传递。- rmodl = fcrmodel()用于初始化模型。
- print(rmodl)用于打印模型架构。
import torch
import torch.nn.functional as func
from torch import nn
class fcrmodel(nn.Module):
def __init__(self):
super().__init__()
self.fc = nn.Linear(18, 14)
self.fc1 = nn.Linear(14, 12)
self.fc2 = nn.Linear(12, 3)
def forward(self, z):
z = func.relu(self.fc1(z))
z = func.relu(self.fc2(z))
z = torch.sigmoid(self.fc3(z))
return z
rmodl = fcrmodel()
print(rmodl)
输出:
在下面的输出中，我们可以看到 PyTorch 全连接层 relu activation 打印在屏幕上。
PyTorch fully connected relu
你可能也喜欢阅读下面的 PyTorch 教程。
- PyTorch nn Conv2d
- 【numpy 指针为张量
- PyTorch 线性回归
- PyTorch 保存模型–完整指南
- PyTorch 激活功能【有 11 个例子】
- Adam 优化器 PyTorch 及示例
- PyTorch 二元交叉熵
因此，在本教程中，我们已经讨论了 PyTorch 全连接层，我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch 全连接层
- PyTorch 全连接层初始化
- PyTorch 全连接层输入大小
- PyTorch cnn 全连接层
- PyTorch 2d 全连接层
- PyTorch 具有 128 个神经元的全连接层
- PyTorch 全连接层，带脱落
- PyTorch 全连接层 relu
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch 超参数调谐
在这个 Python 教程中，我们将学习 Python 中的 PyTorch 超参数调优来构建平均模型和高精度模型之间的差异。此外，我们还将介绍与 PyTorch 超参数调整相关的不同示例。我们也将讨论这些话题。
- PyTorch 超参数调谐
- PyTorch 闪电超参数调谐
- PyTorch 几何超参数调谐
目录
PyTorch 超参数调谐
在本节中，我们将学习 python 中的 PyTorch 超参数调优。
PyTorch 超参数调整被定义为在平均模型或高度精确模型之间产生差异的过程。
代码:
在下面的代码中，我们将导入所有必需的库，如 导入 torch 、导入 matplotlib.pyplot* 、导入 numpy 作为 np 、导入 torch.nn.functional 作为 func 、从 torch 导入 nn、导入数据集、从 torchvision 导入转换、* 导入请求、从 PIL 导入图像
- 变换=变换。撰写([转换。调整大小((32，32))，变换。ToTensor()，转换。Normalize((0.7，0.7，0.7)，(0.7，0.7)，0.7))]):transforms . compose()函数允许我们将多个转换链接在一起，作为 composed 的第一个参数传递。
- 训练数据集=数据集。CIFAR10(root= '。/data '，train=True，download=True，transform=transform) 用于加载 CIFAR 数据集。
- train loader = torch . utils . data . data loader(dataset = train dataset，batch_size=100，shuffle=True) 用于声明训练加载器。
- classes=('飞机'，'汽车'，'鸟'，'猫'，'亲爱的'，'狗'，'青蛙'，'马'，'船'，'卡车'):我们在这里声明类的列表。
data ITER = ITER(train loader)用于获取一些随机的训练图像。- figure = plot . figure(figsize =(25，4)) 用于绘制图形。
- 班莱尼特(nn。Module): 用于借助 init 和 forward()方法创建模型类。
- model=LeNet()。【to(device)】T1 用于创建模型的实例。
- criteron=nn。用来定义一个损失函数。
- optimizer = torch . optim . Adam(model . parameters()、lr=0.001) 用于初始化优化器。
- loss1=criteron(outputs，labels) 用于计算总分类交叉熵损失。
- _，preds=torch.max(outputs，1) 用于查找我们的网络的精度。
loss+=loss1.item()用于跟踪每个时期的损失。- 打印(' validation_loss:{:.4f}，{:.4f} '。format(valepoch_loss，valepoch _ ACC . item())用于打印验证损失和验证准确度。
# Importing Libraries
import torch
import matplotlib.pyplot as plot
import numpy as np
import torch.nn.functional as func
from torch import nn
from torchvision import datasets,transforms
import requests
from PIL import Image
# Using the device
device=torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# Using Compose() method of transform
transform = transforms.Compose(
[transforms.Resize((32,32)),transforms.ToTensor(),
transforms.Normalize((0.7, 0.7, 0.7), (0.7, 0.7, 0.7))])
# Load the CIFAR10 train and validate dataset
traindataset=datasets.CIFAR10(root='./data',train=True,download=True,transform=transform)
valdataset=datasets.CIFAR10(root='./data',train=False,download=True,transform=transform)
# Declaring the train loaders and validate loaders
trainloader=torch.utils.data.DataLoader(dataset=traindataset,batch_size=100,shuffle=True)
valloader=torch.utils.data.DataLoader(dataset=valdataset,batch_size=100,shuffle=False)
# Declare the list of classes
classes=('plane','car','bird','cat','dear','dog','frog','horse','ship','truck')
# Functions to show an images
def im_convert(tensor):
image=tensor.cpu().clone().detach().numpy()
image=image.transpose(1,2,0)
print(image.shape)
image=image*(np.array((0.5,0.5,0.5))+np.array((0.5,0.5,0.5)))
image=image.clip(0,1)
return image
# Get some random training images
dataiter=iter(trainloader)
images,labels=dataiter.next()
# Plot the figures
figure=plot.figure(figsize=(25,4))
for idx in np.arange(20):
axis=figure.add_subplot(2,10,idx+1)
plot.imshow(im_convert(images[idx]))
axis.set_title(classes[labels[idx].item()])
# Create a model class
class LeNet(nn.Module):
def __init__(self):
super().__init__()
self.conv1=nn.Conv2d(3,16,3,1, padding=1)
self.conv2=nn.Conv2d(16,32,3,1, padding=1)
self.conv3=nn.Conv2d(32,64,3,1, padding=1)
self.fully1=nn.Linear(4*4*64,500)
self.dropout1=nn.Dropout(0.5)
self.fully2=nn.Linear(500,10)
def forward(self,y):
y=func.relu(self.conv1(y))
y=func.max_pool2d(y,2,2)
y=func.relu(self.conv2(y))
y=func.max_pool2d(y,2,2)
y=func.relu(self.conv3(y))
y=func.max_pool2d(y,2,2)
#Reshaping the output into desired shape
y=y.view(-1,4*4*64)
#Applying relu activation function to our first fully connected layer
y=func.relu(self.fully1(y))
y=self.dropout1(y)
#We will not apply activation function here because we are dealing with multiclass dataset
y=self.fully2(y)
return y
# Creating an instance of the model
model=LeNet().to(device)
# Define Loss Function
criteron=nn.CrossEntropyLoss()
# Use the optimizer
optimizer=torch.optim.Adam(model.parameters(),lr=0.001)
# Specify the number of epochs
epochs=5
losshistory=[]
correcthistory=[]
valloss_history=[]
valcorrect_history=[]
# Validate the model
for e in range(epochs):
loss=0.0
correct=0.0
valloss=0.0
valcorrect=0.0
# Define a for loop statement for labels and inputs
for input,labels in trainloader:
# Itetrate through our batch of the images
input=input.to(device)
labels=labels.to(device)
outputs=model(input)
# Calculate the total categorical cross entropy loss
loss1=criteron(outputs,labels)
optimizer.zero_grad()
loss1.backward()
optimizer.step()
# Find the accuracy of our network
_,preds=torch.max(outputs,1)
# Keep the track of the losses at every epochs
loss+=loss1.item()
correct+=torch.sum(preds==labels.data)
else:
with torch.no_grad():
# Define a for loop statement for labels and inputs
for val_input,val_labels in valloader:
# Itetrate through our batch of the images
val_input=val_input.to(device)
val_labels=val_labels.to(device)
val_outputs=model(val_input)
# Calculate the total categorical cross entropy loss
val_loss1=criteron(val_outputs,val_labels)
_,val_preds=torch.max(val_outputs,1)
# Calculate the validation loss and accuracy
valloss+=val_loss1.item()
valcorrect+=torch.sum(val_preds==val_labels.data)
epoch_loss=loss/len(trainloader)
epoch_acc=correct.float()/len(trainloader)
losshistory.append(epoch_loss)
correcthistory.append(epoch_acc)
# Calculate the validation epoch loss
valepoch_loss=valloss/len(valloader)
valepoch_acc=valcorrect.float()/len(valloader)
valloss_history.append(valepoch_loss)
valcorrect_history.append(valepoch_acc)
# print validation loss and validation accuracy
print('training_loss:{:.4f},{:.4f}'.format(epoch_loss,epoch_acc.item()))
print('validation_loss:{:.4f},{:.4f}'.format(valepoch_loss,valepoch_acc.item()))
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到训练损失和验证损失以及 CIFAR 数据集图像打印在屏幕上。
PyTorch hyperparameter tuning
这样，我们了解了 PyTorch 超参数调谐。
阅读: PyTorch 线性回归
PyTorch 闪电超参数调谐
在本节中，我们将学习 python 中的 PyTorch lightning 超参数调优。
PyTorch lightning 是一个轻量级的高性能框架。它让人工智能快速迭代。
PyTorch 超参数调整可以建立平均模型或高度精确模型之间的差异。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch，import functional as F，import MNISTDataModule from pl _ bolts . data modules，import os。
- 类 LightningClassifier(pl。LightningModule): 这里我们借助 init()和 forward()方法定义一个模型类。
- def config optimizer(self):用于定义配置优化器。
- def trainstep(self，trainingbatch，batch_index): 用于定义训练步骤。
- def validstep(self，validationbatch，batch_index): 用于定义验证步骤。
- MNISTDataModule(数据目录=数据目录)。用于下载数据的 prepare_data()。
print(analysis . best _ config)用于通过 print()函数打印分析最佳配置。
# Importing Libraries
import torch
from torch.nn import functional as F
import pytorch_lightning as pl
from pl_bolts.datamodules import MNISTDataModule
import os
from ray.tune.integration.pytorch_lightning import TuneReportCallback
# Define a model class
class LightningClassifier(pl.LightningModule):
def __init__(self, config, data_dir=None):
super(LightningClassifier, self).__init__()
self.data_dir = data_dir or os.getcwd()
self.lr = config["lr"]
layer, layer_1 = config["layer"], config["layer_1"]
# mnist images are (1, 28, 28) (channels, width, height)
self.layer = torch.nn.Linear(28 * 28, layer)
self.layer_1 = torch.nn.Linear(layer, layer_1)
self.layer_2 = torch.nn.Linear(layer_1, 12)
self.accuracy = pl.metrics.Accuracy()
def forward(self, m):
batchsize, channels, width, height = m.size()
m = m.view(batchsize, -1)
m = self.layer(m)
m = torch.relu(m)
m = self.layer_1(m)
m = torch.relu(m)
m = self.layer_2(m)
m = torch.log_softmax(m, dim=1)
return m
def configoptimizers(self):
return torch.optim.Adam(self.parameters(), lr=self.lr)
def trainstep(self, trainingbatch, batch_index):
m, n = trainingbatch
logits = self.forward(m)
loss = F.nll_loss(logits, n)
acc = self.accuracy(logits, n)
self.log("ptl/train_loss", loss)
self.log("ptl/train_accuracy", acc)
return loss
def validstep(self, validationbatch, batch_index):
m, n = validationbatch
logits = self.forward(m)
loss = F.nll_loss(logits, n)
acc = self.accuracy(logits, n)
return {"val_loss": loss, "val_accuracy": acc}
def validationepoch_end(self, outputs):
avg_loss = torch.stack(
[m["val_loss"] for m in outputs]).mean()
avg_acc = torch.stack(
[m["val_accuracy"] for m in outputs]).mean()
self.log("ptl/val_loss", avg_loss)
self.log("ptl/val_accuracy", avg_acc)
def training_mnist(config, data_dir=None, num_epochs=10, num_gpus=0):
model = LightningClassifier(config, data_dir)
dl = MNISTDataModule(
data_dir=data_dir, num_workers=1, batch_size=config["batch_size"])
metrices = {"loss": "ptl/val_loss", "acc": "ptl/val_accuracy"}
trainer = pl.Trainer(
max_epochs=num_epochs,
gpus=num_gpus,
progress_bar_refresh_rate=0,
callbacks=[TuneReportCallback(metrices, on="validation_end")])
trainer.fit(model, dl)
import tempfile
from ray import tune
numsamples = 12
numepochs = 12
# set this to higher if using GPU
gpusper_trial = 0
data_dir = os.path.join(tempfile.gettempdir(), "mnist_data_")
# Download data
MNISTDataModule(data_dir=data_dir).prepare_data()
config = {
"layer": tune.choice([34, 66, 130]),
"layer_1": tune.choice([66, 130, 260]),
"lr": tune.loguniform(1e-4, 1e-1),
"batch_size": tune.choice([34, 66, 130]),
}
trainable = tune.with_parameters(
training_mnist,
data_dir=data_dir,
num_epochs=numepochs,
num_gpus=gpusper_trial)
analysis = tune.run(
trainable,
resources_per_trial={
"cpu": 1,
"gpu": gpusper_trial
},
metric="loss",
mode="min",
config=config,
num_samples=numsamples,
name="tune_mnist")
print(analysis.best_config)
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到 Pytorch lightning 超参数调整批次大小、层、层 1 和学习率值打印在屏幕上。
PyTorch hyperparameter tuning lightning
PyTorch lightning 超参数调整就是这样让人工智能快速迭代的。
阅读: PyTorch 激活功能
PyTorch 几何超参数调谐
在本节中，我们将学习 python 中的 PyTorch 几何超参数调整。
PyTorch 几何超参数调整被定义为作为参数传递给估计器类的构造函数的参数。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch、import torchvision、import transforms from torch vision。
- 变换=变换。撰写([转换。ToTensor()]): 这里我们使用了 conpose()的转换方法，这将允许我们将多个转换链接在一起，并作为 composed，will transform.ToTensor 的第一个参数传递。
- trainset = torch vision . datasets . fashion mnist(root = '。/data '，train=True，download=True，transform=transform) 用于加载数据集。
- NN 类(NN。Module): 用于使用 init()和 forward()方法定义模型类。
- training_size，validation_size = 48000，12000 用于描述训练规模和验证规模。
- self.conv = nn。Conv2d(1，32，kernel_size=3，stride=1，padding=1) 用作输入 1 通道，有 32 个滤波器，每个滤波器的内核大小为 3。
- self.fc = nn。线性(12833，32) 作为全连通层。
- 打印(' training_size:'，training_size) 用于打印训练尺寸。
- print('validation_size:'，validation_size) 用于打印验证尺寸。
- training _ loader = data loader(training，batch_size=100，shuffle=False) 用于训练数据加载器。
- 判据= nn。CrossEntropyLoss() 用于定义损失。
- 优化器= optim。Adam(net.parameters()，lr=0.001) 用于初始化优化器。
- plot.figure(figsize=(16，6)) 用于绘制图形。
plot.show()用于在屏幕上显示图。- 打印(f '测试精度:{正确/总计:. 3f} \n' ) 用于打印测试精度。
- classes = ('T-Shirt '，'连衣裙'，'套头衫'，'裤子'，'外套'，'包'，'衬衫'，'运动鞋'，'凉鞋'，'踝靴'):我们在这里声明类的列表。
- print('精度%5s : %2d %%' % ( classes[n]，100 * class _ correct[n]/class _ total[n])用于使用 print()函数打印精度。
# Importing libraries
import torch
import torchvision
from torchvision import transforms
torch.manual_seed(0)
# Using compose() method
transform = transforms.Compose([transforms.ToTensor()])
# Load dataset
trainset = torchvision.datasets.FashionMNIST(root='./data', train=True, download=True, transform=transform)
testset = torchvision.datasets.FashionMNIST(root='./data', train=False, download=True, transform=transform)
from statistics import mean
import numpy as np
import matplotlib.pyplot as plot
import pandas as pd
import torch
import torchvision
from torchvision import transforms
import torch.nn as nn
import torch.nn.functional as fun
from torch.utils.data import DataLoader, TensorDataset
# Define the model class
class NN(nn.Module):
def __init__(self):
super(NN, self).__init__()
# Input 1 channel with 32 filters each with kernel_size=3
self.conv = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)
self.conv1 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
self.conv2 = nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1)
self.batch_norm = nn.BatchNorm2d(32)
self.batch_norm1 = nn.BatchNorm2d(64)
self.batch_norm2 = nn.BatchNorm2d(128)
self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
self.dropout25 = nn.Dropout2d(p=0.25)
# Fully connected layer
self.fc = nn.Linear(128*3*3,32)
self.fc1 = nn.Linear(32, 10)
def forward(self, y):
y = self.pool(fun.relu(self.batch_norm(self.conv(y))))
y = self.dropout25(y)
y = self.pool(fun.relu(self.batch_norm1(self.conv1(y))))
y = self.dropout25(y)
y = self.pool(fun.relu(self.batch_norm2(self.conv2(y))))
y = self.dropout25(y)
y = y.view(y.size(0),-1)
y = self.fc(y)
y = self.fc1(y)
return y
# Describe the variables
training_size, validation_size = 48000, 12000
scale_tensor = trainset.data / 255.0
scale_tensor = scale_tensor.view(scale_tensor.size(0), 1, 28, 28)
scale_trainset = TensorDataset(scale_tensor, trainset.targets)
training, validation = torch.utils.data.random_split(scale_trainset, [training_size, validation_size])
print('training_size: ', training_size)
print('validation_size: ', validation_size)
training_loader = DataLoader(training, batch_size=100, shuffle=False)
validation_loader = DataLoader(validation, batch_size=100, shuffle=False)
net = NN()
device = 'cuda'
net.to(device)
import torch.optim as optim
# Define Loss function
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=0.001)
epochs = 30
batches = 0
training_losses = list()
validation_losses = list()
validation_acces = list()
batch_lst = list()
batches = 0
validation_loss = 0
# Train NN
# loop over the dataset multiple times
for epoch in range(1,epochs+1):
running_loss = 0.0
for n, data in enumerate(training_loader):
# get the inputs; data is a list of [inputs, labels]
inputs, labels = data
if torch.cuda.is_available():
inputs = inputs.cuda()
labels = labels.cuda()
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
# print every 2000 mini-batches
if n % 100 == 99:
net.eval()
correct = 0
for m, val_data in enumerate(validation_loader):
valid_X, valid_y = val_data
valid_X = valid_X.cuda()
valid_y = valid_y.cuda()
outputs = net(valid_X)
v_loss = criterion(outputs, valid_y)
validation_loss += v_loss.item()
preds = outputs.data.max(1, keepdim=True)[1]
correct += preds.eq(valid_y.view_as(preds)).cpu().sum().item()
log = f"epoch: {epoch} {n+1} " \
f"train_loss: {running_loss / 100:.3f} " \
f"val_loss: {validation_loss / 100:.3f} " \
f"Val Acc: {correct/len(validation_loader.dataset):.3f}"
training_losses.append(running_loss / 100)
validation_losses.append(validation_loss / 100)
validation_acces.append(correct/len(validation_loader.dataset))
batches += 100
batch_lst.append(batches)
valid_loss = 0
print(log)
running_loss = 0.0
net.train()
print('Finished Training')
# Plot the figure
plot.figure(figsize=(16,6))
plot.plot(batch_lst, training_losses, '-o', label='Training loss')
plot.plot(batch_lst, valid_losses, '-o', label='Validation loss')
plot.legend()
plot.title('Learning curves')
plot.xlabel('Batches')
plot.ylabel('Loss')
plot.xticks(batch_lst,rotation = 90)
plot.tight_layout()
plot.savefig("result.png")
plot.show()
scale_tensr = testset.data / 255.0
scale_tensr = scale_tensr.view(scale_tensr.size(0), 1, 28, 28)
scale_testset = TensorDataset(scale_tensr, testset.targets)
testing_loader = DataLoader(scale_testset, batch_size=100, shuffle=False)
correct = 0
total = 0
net.eval()
for data in testing_loader:
testing_X, testing_y = data
testing_X = testing_X.cuda()
testing_y = testing_y.cuda()
outputs = net(testing_X.float())
_, predicted = torch.max(outputs.data, 1)
total += testing_y.size(0)
correct += (predicted == testing_y).sum().item()
print(f'Test Accuracy: {correct/total:.3f} \n' )
classes = ('T-Shirt', 'Dress', 'Pullover', 'Trouser',
'Coat', 'Bag', 'Shirt', 'Sneaker', 'Sandal', 'Ankle Boot')
class_correct = list(0\. for n in range(10))
class_total = list(0\. for n in range(10))
with torch.no_grad():
for data in testing_loader:
testing_X, testing_y = data
testing_X = testing_X.cuda()
testing_y = testing_y.cuda()
_, predicted = torch.max(outputs, 1)
d = (predicted == testing_y).squeeze()
for n in range(100):
label = testing_y[n]
class_correct[label] += d[n].item()
class_total[label] += 1
for n in range(10):
print('Accuracy of %5s : %2d %%' % (
classes[n], 100 * class_correct[n] / class_total[n]))
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到 PyTorch 几何超参数调节精度值打印在屏幕上。
PyTorch hyperparameter tuning geometry
这样，我们了解了 PyTorch 几何超参数调谐的工作原理。
您可能也喜欢阅读下面的 Python PyTorch 教程。
因此，在本教程中，我们讨论了 PyTorch 超参数调优,我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch 超参数调谐
- PyTorch 闪电超参数调谐
- PyTorch 几何超参数调谐
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch Leaky ReLU 有用的教程
在本 Python 教程中，我们将学习 PyTorch leaky ReLU 函数。这个函数是一个激活函数，用于解决神经元死亡的问题。此外，我们将涵盖与 PyTorch 泄漏 ReLU 相关的不同例子。也涵盖了这些主题。
- 皮托里奇注意到了
- PyTorch 泄漏 relu 示例
- pytorch leaky 在 inplace 站了起来
- PyTorch 渗漏斜坡
- PyTorch 泄漏 relu 功能
- pytorch leaky relu vs relu
目录
- pytorch league relu
- PyTorch 泄漏 relu 示例
- pytorch leach 在 inlace中指出
- PyTorch 泄漏 relu 斜率
- PyTorch 泄漏 relu 功能
- pytorch league relu vs relu
pytorch league relu
在这一节中，我们将学习 python 中的 PyTorch Leaky Relu 是如何工作的。
PyTorch 泄漏 relu 是一个激活函数。如果输入是负的，函数的导数不为零，并且神经元的学习速率不停止，则它是有益的函数。这个函数用来解决神经元死亡的问题。
语法:
leaky relu 的语法是:
torch.nn.LeakyReLU(negative_slope = 0.01, inplace = False)
参数
以下是在 LeakyReLU() 函数中使用的参数。
- 负 _ 斜率:用于控制负斜率的角度。负斜率的默认值为 1e-2。
- 就地:可以选择就地操作。inplace 的默认值为 False。如果 inplace 的值为 True，它将直接改变输入，而不分配任何额外的输出。
这样，我们理解了 PyTorch leaky relu 在 python 中是如何工作的。
阅读: PyTorch 激活功能
PyTorch 泄漏 relu 示例
在本节中，我们将借助 python 中的一个示例来了解 PyTorch leaky relu。
PyTorch 泄漏 relu 被定义为激活函数。如果输入是负的，函数的导数将是一个非常小的分数，并且永远不会为零。
这确保了神经元的学习速率在反向传播期间不会停止，从而避免了神经元死亡的问题。
代码:
在下面的代码中，首先我们将导入 torch 模块，然后我们将 torch.nn 作为 nn 导入。
- n = nn。LeakyReLU(0.2) 这里我们使用的是 LeakyReLU()函数。
input = torch.randn(4)这里我们用 torch.random()函数来描述输入变量。output = n(input)这里我们声明输出变量。print(output)用于通过 print()函数打印输出值。
# Import library
import torch
import torch.nn as nn
# Using the leakyReLU()
n = nn.LeakyReLU(0.2)
# Describing the input variable
input = torch.randn(4)
# Declaring the output variable
output = n(input)
print(output)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch leaky relu 值被打印在屏幕上。
PyTorch leaky relu example
PyTorch 泄漏 relu 的实现就是这样完成的。
阅读: PyTorch 全连接层
pytorch leach 在 inlace中指出
在这一节中，我们将学习 PyThon 中的 PyTorch leaky relu inplace 。
PyTorch 泄漏 relu 在位被定义为激活函数，在这个函数中，我们使用在位的参数。
语法:
PyTorch leaky relu inplace 的语法:
torch.nn.LeakyReLU(inplace=True)
参数:
以下是参数:
inplace = True这意味着它将直接改变输入而不分配任何额外的输出，inplace 参数的默认值为 False。
这就是 Pytorch leaky relu 函数中 inplace 参数的工作方式。
阅读: PyTorch 车型总结
PyTorch 泄漏 relu 斜率
在这一节中，我们将了解 PyTorch leaky relu 如何在 python 中工作。
在前进之前，我们应该有一个关于斜率的知识。斜坡是一边比另一边高的表面。
PyTorch 泄漏 relu 斜率定义为当输入为负且函数的微分不为零时。
语法:
泄漏 relu 斜率的语法:
torch.nn.LeakyReLU(negative_slope = 0.01)
参数:
以下是泄漏 relu 的参数:
负 _ 斜率:用于控制负斜率的角度。负斜率的默认值为 1e-2。
代码:
在下面的代码中，首先我们将导入 torch 模块，然后我们将 torch.nn 作为 nn 导入。
- s = nn。LeakyReLU(0.4) 用于定义 LeakyReLU()函数，在该函数中，我们使用参数 0.4 来控制负斜率。
- 输入=火炬。张量([2，-4，5，-6]) 用于创建一个带数组的张量。
output = s(input)这里我们声明输出变量。print(output)用于借助 print()函数打印输出值。
# Importing libraries
import torch
import torch.nn as nn
# Defining Leaky relu and the parameter 0.4 is passed to control the negative slope
s = nn.LeakyReLU(0.4)
# Creating a Tensor with an array
input = torch.Tensor([2,-4,5,-6])
# Declaring the output variable
output = s(input)
# Print the output
print(output)
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到 PyTorch leaky relu slope 值打印在屏幕上。
PyTorch leaky relu slope
因此，有了这个，我们理解了 PyTorch 渗漏的 relu 斜坡是如何工作的。
阅读: PyTorch 逻辑回归
PyTorch 泄漏 relu 功能
在这一节中，我们将学习 python 中的 PyTorch leaky relu 函数。
PyTorch leaky relu 泛函被定义为用于解决神经元死亡问题的过程。
这个功能非常有用。如果输入值为负，则函数的导数不为零。
语法:
PyTorch leaky relu 函数的语法:
torch.nn.functional.leaky_relu(input,negative_slope = 0.01, inplace = False)
参数:
以下是泄漏 relu 功能中使用的参数:
- 负 _ 斜率:用于控制负斜率的角度。负斜率的默认值为 1e-2。
- 就地:可以选择就地操作。inplace 的默认值为 False。如果 inplace 的值是 T，它将直接改变输入，而不分配任何额外的输出。
Pytorch 泄漏 relu 函数就是这样工作的。
阅读: PyTorch 模型评估+示例
pytorch league relu vs relu
在这一节中，我们将了解 PyTorch leaky relu 和 python 中的 relu 之间的区别。
pytorch league relu:
漏 relu 函数非常有用。在 leaky relu 中，如果输入值为负，导数不为零。
泄漏的 relu 还解决了神经元死亡的问题，并且神经元的学习速率不会停止。
举例:
在下面的代码中，首先我们将导入所有必要的库，如 import torch 和 import torch.nn as nn。
re = nn。LeakyReLU(0.6): 这里我们定义的是 LeakyReLU()函数。
输入=火炬。张量([2，-3，4，-6]) 用于创建一个带数组的张量。
output = re(input) 用于将数组传递给 leaky relu 函数。
打印(输出)用于使用 print()函数打印输出。
# Importing libraries
import torch
import torch.nn as nn
# defining Leaky relu
re = nn.LeakyReLU(0.6)
# Creating a Tensor with an array
input = torch.Tensor([2,-3,4,-6])
# Passing the array to leaky relu function
output = re(input)
# Print the output
print(output)
输出:
运行上面的例子后，我们得到下面的输出，我们可以看到 PyTorch leaky relu 值打印在屏幕上。
PyTorch leaky relu
PyTorch relu:
relu 函数是非线性且可微分的函数。在 relu 中，如果输入是负的，导数变为零，这导致神经元死亡和神经元的学习速率停止。
举例:
在下面的代码中，首先我们将导入所有必要的库，如 import torch 和 import torch.nn as nn。
- lr = nn。ReLU(): 这里我们定义 ReLU()函数。
- 输入=火炬。张量([2，-3，4，-6]) 用于创建一个带数组的张量。
output = lr(input)用于将数组传递给 relu 函数。- 打印(输出)用于借助 print()函数进行打印。
# Importing libararies
import torch
import torch.nn as nn
# defining relu
lr = nn.ReLU()
# Creating a Tensor with an array
input = torch.Tensor([2,-3,4,-6])
# Passing the array to relu function
output = lr(input)
# Print output
print(output)
输出:
在下面的输出中，您可以看到 PyTorch relu 值打印在屏幕上。
PyTorch relu
这样，我们就理解了 PyTorch 泄漏 relu 和 relu 函数之间的区别。
另外，再看看一些 PyTorch 教程。
因此，在本教程中，我们讨论了 PyTorch Leaky ReLU 并涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- 皮托里奇注意到了
- PyTorch 泄漏 relu 示例
- pytorch leaky 在 inplace 站了起来
- PyTorch 渗漏斜坡
- PyTorch 泄漏 relu 功能
- pytorch leaky relu vs relu
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch Lenet 简介
PyTorch Lenet 是一个简单的卷积神经网络，我们可以在 32 x 32 像素的灰度级上训练该模型，它具有 Leranable 参数。详细来说，我们将讨论在 Python 中使用 PyTorch 的 Lenet。
此外，我们还将介绍与 PyTorch Lenet 相关的不同示例。我们将讨论这些话题。
- PyTorch Lenet
- PyTorch Lenet 实施
- 皮托奇·兰内·姆尼斯特
- PyTorch Lenet cifar10
- 皮托奇·勒内特五世
目录
PyTorch Lenet
在这一节中，我们将学习 python 中的 PyTorch Lenet 。
Lenet 被定义为一个简单的卷积神经网络。卷积神经网络是一种前馈神经网络。
Lenet 模型可以在大小为 32 x 32 像素的灰度图像上进行训练。它有可学习的参数。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch，import torch.nn as nn，import torch . nn . functional as func，import summary from torchsummary。
- 类 leNetModel(nn。Module): 这里我们通过使用 init()和 forward()方法来使用模型类。
- y = torch.randn(2，2，34，34): 这里我们用 torch.randn()函数来描述变量。
- mdl = leNetModel(): 这里我们正在初始化模型。
- summary(mdl，(2，34，34)) 用于得到模型的摘要。
import torch
import torch.nn as nn
import torch.nn.functional as func
from torchsummary import summary
class leNetModel(nn.Module):
def __init__(self):
super(leNetModel,self).__init__()
#Here we are starting the implementation of Layer 1 which has six kernels of size 5x5 with padding 0 and stride 1
self.conv = nn.Conv2d(in_channels=2,out_channels=8,kernel_size=(5,5),padding=0,stride=1)
#Here we are starting the implementation of Layer 3 which has eighteen kernels of size 5x5 with padding 0 and stride 1
self.conv1 = nn.Conv2d(in_channels = 8, out_channels = 18,kernel_size = (5,5),padding=0,stride=1)
# Here we are starting the implementation of Layer 5 which is basically flattening the data
self.conv2 = nn.Conv2d(in_channels = 18, out_channels = 122,kernel_size = (5,5),padding=0,stride=1)
#Here we are starting the implementation of Layer 6 which has eighty six Linear Neurons
self.L1 = nn.Linear(122,86)
#Here we are starting the implementation of Layer 7 which has ten Linear Neurons and input of 84
self.L2 = nn.Linear(86,12)
# Here we are using pooling of size 2 and stride 2 in this architecture
self.pool = nn.AvgPool2d(kernel_size = 2, stride = 2)
#Here we are using tanh as an activation function so we will use tanh at all layers excluding F7.
self.act = nn.Tanh()
#Here we are implementing forward function to produce entire flow of the architecture.
def forward(self,y):
y = self.conv(y)
# Here we are using tanh as an activation function in this architecture so we will use tanh at all layers excluding F7.
y = self.act(y)
# Here this will be passed from pooling
y = self.pool(y)
# The next stage is convolution
y = self.conv1(y)
y = self.act(y)
y = self.pool(y)
# The next we will pass conv3, here we will not pass data from pooling as per Architecture
y = self.conv2(y)
y = self.act(y)
# Now the data should be flaten and it would be passed from FullyConnected layers.
y = y.view(y.size()[0], -1)
y = self.L1(y)
y = self.act(y)
y = self.L2(y)
return y
y = torch.randn(2,2,34,34)
mdl = leNetModel()
summary(mdl,(2,34,34))
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch Lenet 模型被打印在屏幕上。
PyTorch Lenet
因此，有了这个，我们理解了 PyTorch Lenet 模型。
阅读: PyTorch 整形张量
PyTorch Lenet 实施
在这一节中，我们将通过一个例子来学习如何实现 PyTorch Lenet。
PyTorch Lenet 是一种卷积神经网络结构。这是贝尔实验室的 Yann LeCun 在 1989 年提出的。它较早地将反向传播算法应用到实际应用中。
代码:
在下面的代码中，我们首先导入所有必要的库，如 import torch，import torch.nn as nn，import torch . nn . func as func。
- 班莱尼特(nn。Module): 下面是使用 init()和 forward()方法的 lenet 模型类。
params = list(net . parameters())用于打印参数的长度。print(out)用于借助 print()函数打印输出。
import torch
import torch.nn as nn
import torch.nn.functional as func
class lenet(nn.Module):
def __init__(self):
super(lenet, self).__init__()
# Here is one input image channel, six output channels, 5x5 square convolution
self.conv = nn.Conv2d(1, 6, 5)
self.conv1 = nn.Conv2d(6, 16, 5)
# operation y = Wx + b
self.fc = nn.Linear(16 * 5 * 5, 120) # 5*5 from image dimension
self.fc1 = nn.Linear(120, 84)
self.fc2 = nn.Linear(84, 10)
def forward(self, y):
# Here we are doing max pooling over a (2, 2) window
y = func.max_pool2d(func.relu(self.conv(y)), (2, 2))
# Here if the size is a square, you can specify with a single number
y = func.max_pool2d(func.relu(self.conv1(y)), 2)
y = torch.flatten(y, 1)
y = func.relu(self.fc(y))
y = func.relu(self.fc1(y))
y = self.fc2(y)
return y
net = lenet()
print(net)
# Print the lenght of the parameters
params = list(net.parameters())
print(len(params))
print(params[0].size())
#Print the output
input = torch.randn(1, 1, 32, 32)
out = net(input)
print(out)
输出:
运行上面的代码后，我们得到下面的输出，您可以看到 PyTorch Lenet 的实现已经在屏幕上完成。
PyTorch Lenet Implementation
这样，我们理解了 PyTorch Lenet 的实现。
阅读: Jax Vs PyTorch
pytorch lenet mnitst
在这一节中，我们将学习 python 中的 PyTorch Lenet MNIST 。
这里，我们使用卷积神经网络定义 lenet 模型，并使用 MNIST 数据集的分类。MNIST 数据集包含灰度图像的数量。
代码:
在下面的代码中，我们将首先导入所有必要的库，如 import torch、import torch.nn as nn、import torchvision 和 import torch . transforms as transforms。
- device = torch . device(' cuda ' if torch . cuda . is _ available()else ' CPU ')作为可用设备使用。
- training dtset = torch vision . datasets . Mn ist(root = '。/data '，train = True，transform = transforms。撰写([转换。调整大小((32，32))，变换。ToTensor()，转换。Normalize(mean = (0.1307，)，std = (0.3081，)])，download = True) 用于加载数据集。
- train ldr = torch . utils . data . DataLoader(dataset = training dtset，batch_size = batchsiz，shuffle = True) 用于定义为 data loader。
- lass lenet(nn。这里我们通过使用 init()和 forward()方法来定义一个 lenet 模型类。
- l = nn。CrossEntropyLoss() 被定义为损失函数。
- optimizer = torch . optim . Adam(MDL . parameters()、lr=lr) 用于初始化优化器。
ttlstep = len(trainldr)用于打印总步数。- 打印(' Epoch [{}/{}]，Step [{}/{}]，Loss: {:.4f} '。format(epoch+1，nepochs，x+1，ttlstep，loss . item())用于打印 epoch 和 loss。
# Importing Libraries
import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms
# Define variable
batchsiz = 52
nclasses = 10
lr = 0.001
nepochs = 5
# Describing the device
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# Loading the dataset
trainingdtset = torchvision.datasets.MNIST(root = './data',
train = True,
transform = transforms.Compose([
transforms.Resize((32,32)),
transforms.ToTensor(),
transforms.Normalize(mean = (0.1307,), std = (0.3081,))]),
download = True)
testingdtset = torchvision.datasets.MNIST(root = './data',
train = False,
transform = transforms.Compose([
transforms.Resize((32,32)),
transforms.ToTensor(),
transforms.Normalize(mean = (0.1325,), std = (0.3105,))]),
download=True)
# Define the data loader
trainldr = torch.utils.data.DataLoader(dataset = trainingdtset,
batch_size = batchsiz,
shuffle = True)
testldr = torch.utils.data.DataLoader(dataset = testingdtset,
batch_size = batchsiz,
shuffle = True)
# Defining the Lenet model
class lenet(nn.Module):
def __init__(self, num_classes):
super(lenet, self).__init__()
self.layer = nn.Sequential(
nn.Conv2d(1, 6, kernel_size=5, stride=1, padding=0),
nn.BatchNorm2d(6),
nn.ReLU(),
nn.MaxPool2d(kernel_size = 2, stride = 2))
self.layer1 = nn.Sequential(
nn.Conv2d(6, 16, kernel_size=5, stride=1, padding=0),
nn.BatchNorm2d(16),
nn.ReLU(),
nn.MaxPool2d(kernel_size = 2, stride = 2))
self.fc = nn.Linear(400, 120)
self.relu = nn.ReLU()
self.fc1 = nn.Linear(120, 84)
self.relu1 = nn.ReLU()
self.fc2 = nn.Linear(84, num_classes)
def forward(self, y):
outp = self.layer(y)
outp = self.layer1(outp)
outp = outp.reshape(outp.size(0), -1)
outp = self.fc(outp)
outp = self.relu(outp)
outp = self.fc1(outp)
outp = self.relu1(outp)
outp = self.fc2(outp)
return outp
mdl = lenet(nclasses).to(device)
# Defining the loss function
l = nn.CrossEntropyLoss()
# Initializing the optimizer
optimizer = torch.optim.Adam(mdl.parameters(), lr=lr)
# Print the total step
ttlstep = len(trainldr)
ttlstep = len(trainldr)
for epoch in range(nepochs):
for x, (imgs, lbls) in enumerate(trainldr):
imgs = imgs.to(device)
lbls = lbls.to(device)
#Forward pass
output = mdl(imgs)
loss = l(output, lbls)
# Backward and optimize
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (x+1) % 400 == 0:
print ('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'
.format(epoch+1, nepochs, x+1, ttlstep, loss.item()))
输出:
在下面的输出中，您可以看到 PyTorch Lenet MNSIT 的历元和损耗值打印在屏幕上。
PyTorch lenet MNIST
因此，有了这个，我们理解了皮托尔·莱内特·MNIST。
PyTorch Lenet cifar10
在本节中，我们将学习 python 中的 PyTorch Lenet cifar10 。
在继续之前，我们应该对 cifar10 有一些了解。
CIFAR 代表加拿大高级研究所。它是定期用于训练机器学习和计算机视觉算法的图像集合。
这里，我们用 cifar10 数据集描述 lenet 模型。
代码:
在下面的代码中，首先我们将导入所有必要的库，如 import torch、import matplotlib.pyplot as plt、import numpy as np、import torch.nn.functional 等。
- 转换 1 =转换。撰写([转换。调整大小((32，32))，变换。ToTensor()，转换。Normalize((0.7，)，(0.7，)]) 用作变换的合成方法。
- traindst =数据集。CIFAR10(root= '。/data '，train=True，download=True，transform=transform1) 用于加载 cifar10 数据集。
- classes=('飞机'，'汽车'，'猫'，'狗'，'青蛙'，'亲爱的'，'马'，'船'，'卡车'，'鸟'):我们在这里声明类的列表。
- 班莱尼特(nn。Module): 这里我们使用 init(0 和 forward()方法定义 lenet 模型类。
- criteron=nn。CrossEntropyLoss(): 这里我们定义损失函数。
- optimizer = torch . optim . Adam(MDL . parameters()，lr=0.00001) 用于初始化优化器。
- print('training_loss:{:.4f}，{:.4f} '。format(epoch_loss，epoch _ ACC . item())用于打印训练损耗。
- 打印(' validation_loss:{:.4f}，{:.4f} '。format(valepochloss，valepochacc . item())用于打印验证损失。
# Importing libraries
import torch
import matplotlib.pyplot as plt
import numpy as np
import torch.nn.functional as func
import PIL.ImageOps
from torch import nn
from torchvision import datasets,transforms
import requests
from PIL import Image
# Using the device
d=torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# Using the compose method of transforms
transform1=transforms.Compose([transforms.Resize((32,32)),transforms.ToTensor(),transforms.Normalize((0.7,),(0.7,))])
# Loading the dataset
traindst=datasets.CIFAR10(root='./data',train=True,download=True,transform=transform1)
validdst=datasets.CIFAR10(root='./data',train=False,download=True,transform=transform1)
trainldr=torch.utils.data.DataLoader(dataset=traindst,batch_size=100,shuffle=True)
validldr=torch.utils.data.DataLoader(dataset=validdst,batch_size=100,shuffle=False)
# Define the function to show an images
def iconvert(tensor):
img=tensor.cpu().clone().detach().numpy()
img=img.transpose(1,2,0)
print(img.shape)
img=img*(np.array((0.5,0.5,0.5))+np.array((0.5,0.5,0.5)))
img=img.clip(0,1)
return img
# Declare the list of classes
classes=('plane','car','cat','dog','frog','dear','horse','ship','truck','bird')
diter=iter(trainldr)
imgs,lbls=diter.next()
figure=plt.figure(figsize=(25,4))
for index in np.arange(10):
axis=figure.add_subplot(2,10,index+1)
plt.imshow(iconvert(imgs[index]))
axis.set_title(classes[lbls[index].item()])
# Define the model
class LeNet(nn.Module):
def __init__(self):
super().__init__()
self.conv=nn.Conv2d(3,20,5,1)
self.conv1=nn.Conv2d(20,50,5,1)
self.fully=nn.Linear(5*5*50,500)
self.dropout=nn.Dropout(0.5)
self.fully1=nn.Linear(500,10)
def forward(self,y):
y=func.relu(self.conv(y))
y=func.max_pool2d(y,2,2)
y=func.relu(self.conv1(y))
y=func.max_pool2d(y,2,2)
# Reshaping the output
y=y.view(-1,5*5*50)
# Apply the relu activation function
y=func.relu(self.fully(y))
y=self.dropout(y)
y=self.fully1(y)
return y
mdl=LeNet().to(d)
# Define the loss
criteron=nn.CrossEntropyLoss()
# Initialize the optimizer
optimizer=torch.optim.Adam(mdl.parameters(),lr=0.00001)
# Specify the number of epochs
epochs=10
losshistry=[]
crrcthistry=[]
vallosshistry=[]
valcrrcthistry=[]
# Validate the model
for x in range(epochs):
loss=0.0
correct=0.0
valloss=0.0
valcrrct=0.0
for input,lbls in trainldr:
input=input.to(d)
lbls=lbls.to(d)
outputs=mdl(input)
loss1=criteron(outputs,lbls)
optimizer.zero_grad()
loss1.backward()
optimizer.step()
_,preds=torch.max(outputs,1)
loss+=loss1.item()
correct+=torch.sum(preds==lbls.data)
else:
with torch.no_grad():
for valinp,vallbls in validldr:
valinp=valinp.to(d)
vallbls=vallbls.to(d)
valoutps=mdl(valinp)
valloss1=criteron(valoutps,vallbls)
_,val_preds=torch.max(valoutps,1)
valloss+=valloss1.item()
valcrrct+=torch.sum(val_preds==vallbls.data)
epoch_loss=loss/len(trainldr)
epoch_acc=correct.float()/len(trainldr)
losshistry.append(epoch_loss)
crrcthistry.append(epoch_acc)
valepochloss=valloss/len(validldr)
valepochacc=valcrrct.float()/len(validldr)
vallosshistry.append(valepochloss)
valcrrcthistry.append(valepochacc)
print('training_loss:{:.4f},{:.4f}'.format(epoch_loss,epoch_acc.item()))
print('validation_loss:{:.4f},{:.4f}'.format(valepochloss,valepochacc.item()))
输出:
运行上面的代码后，我们得到了下面的输出，其中我们可以看到训练损失和验证损失值被打印在屏幕上。
PyTorch Lenet cifar10
由此，我们了解了 PyTorch Lenet cifar10。
PyTorch Lenet5 MNIST
在这一节中，我们将学习 python 中的 Pytorch Lenet5 。
Lenet5 是高级卷积神经网络。它用于手写字符的识别。
代码:
在下面的代码中，我们将首先导入所有必要的库，如 import torch、import torch.nn as nn、import torchvision 和 import torch . transforms as transforms。
- device = torch . device(' cuda ' if torch . cuda . is _ available()else ' CPU ')作为可用设备使用。
- training dtset = torch vision . datasets . Mn ist(root = '。/data '，train = True，transform = transforms。撰写([转换。调整大小((32，32))，变换。ToTensor()，转换。Normalize(mean = (0.1307，)，std = (0.3081，)])，download = True) 用于加载数据集。
- train ldr = torch . utils . data . DataLoader(dataset = training dtset，batch_size = batchsiz，shuffle = True) 用于定义为 data loader。
- lass lenet(nn。这里我们通过使用 init()和 forward()方法来定义一个 lenet 模型类。
print(mdl)用于打印模型。
# Importing Libraries
import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms
# Define variable
batchsiz = 52
nclasses = 10
lr = 0.001
nepochs = 5
# Describing the device
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# Loading the dataset
trainingdtset = torchvision.datasets.MNIST(root = './data',
train = True,
transform = transforms.Compose([
transforms.Resize((32,32)),
transforms.ToTensor(),
transforms.Normalize(mean = (0.1307,), std = (0.3081,))]),
download = True)
testingdtset = torchvision.datasets.MNIST(root = './data',
train = False,
transform = transforms.Compose([
transforms.Resize((32,32)),
transforms.ToTensor(),
transforms.Normalize(mean = (0.1325,), std = (0.3105,))]),
download=True)
# Define the data loader
trainldr = torch.utils.data.DataLoader(dataset = trainingdtset,
batch_size = batchsiz,
shuffle = True)
testldr = torch.utils.data.DataLoader(dataset = testingdtset,
batch_size = batchsiz,
shuffle = True)
# Defining the Lenet model
class lenet5(nn.Module):
def __init__(self, num_classes):
super(lenet5, self).__init__()
self.layer = nn.Sequential(
nn.Conv2d(1, 6, kernel_size=5, stride=1, padding=0),
nn.BatchNorm2d(6),
nn.ReLU(),
nn.MaxPool2d(kernel_size = 2, stride = 2))
self.layer1 = nn.Sequential(
nn.Conv2d(6, 16, kernel_size=5, stride=1, padding=0),
nn.BatchNorm2d(16),
nn.ReLU(),
nn.MaxPool2d(kernel_size = 2, stride = 2))
self.fc = nn.Linear(400, 120)
self.relu = nn.ReLU()
self.fc1 = nn.Linear(120, 84)
self.relu1 = nn.ReLU()
self.fc2 = nn.Linear(84, num_classes)
def forward(self, y):
outp = self.layer(y)
outp = self.layer1(outp)
outp = outp.reshape(outp.size(0), -1)
outp = self.fc(outp)
outp = self.relu(outp)
outp = self.fc1(outp)
outp = self.relu1(outp)
outp = self.fc2(outp)
return outp
mdl = lenet5(nclasses).to(device)
print(mdl)
输出:
运行上述代码后，我们得到以下输出，可以看到 PyTorch Lenet5 MNIST 模型打印在屏幕上。
PyTorch lenet5 MNIST
你可能也喜欢阅读下面的 PyTorch 教程。
- PyTorch Conv1d
- PyTorch Conv3d
- 如何使用 PyTorch Polar
- PyTorch Full()函数
- PyTorch 查看教程
- PyTorch 二元交叉熵
- 数据加载器指针+示例
- PyTorch 预训练模型
- 指针为 Numpy
因此，在本教程中，我们讨论了 PyTorch Lenet ,我们还讨论了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch Lenet
- PyTorch Lenet 实施
- 皮托奇·兰内·姆尼斯特
- PyTorch Lenet cifar10
- 皮托奇·勒内特五世
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch 线性回归[有 7 个有用的例子]
在本 Python 教程中，我们将学习 PyTorch 线性回归 。 PyTorch 线性回归是一个通过减小距离来寻找因变量和自变量之间的线性关系的过程。此外，我们还将介绍与 PyTorch 线性回归 相关的不同示例。也涵盖了这些主题。
- PyTorch 线性回归
- PyTorch 线性回归从零开始
- PyTorch 线性回归数据加载器
- PyTorch 线性回归损失
- PyTorch 线性回归梯度下降
- 正则化 PyTorch 线性回归
- PyTorch 线性回归精度
目录
- PyTorch 线性回归
- PyTorch 线性回归从零开始
- PyTorch 线性回归数据加载器
- PyTorch 线性回归损失
- PyTorch 线性回归梯度下降
- PyTorch 正则化线性回归
- PyTorch 线性回归精度
PyTorch 线性回归
在本节中，我们将学习 python 中的 、PyTorch 线性回归。
线性回归是一种受监督的机器学习方法，它在因变量和自变量之间找到最佳拟合的线性线。它还发现了因变量和自变量之间的线性关系。
线性回归方程:
Y = Ax+b
PyTorch linear regression
这里 Y 是因变量， x 是自变量， b 是 Y 截距， A 是斜率的系数。
这样，我们理解了 PyTorch 线性回归。
PyTorch 线性回归从零开始
在本节中，我们将从头学习 python 中的 PyTorch 线性回归。
线性回归在因变量和自变量之间建立了线性关系。
在线性回归中，我们建立模型并预测因变量和自变量之间的关系。
代码:
在下面的代码中，我们首先从 torch.autograd 导入所有必需的库，比如导入 torch 和导入变量。
- Xdt =可变(火炬。张量([[2.0]，[4.0]，[6.0]]):这里我们定义的是变量 Xdt (Xdata)。这里 Xdt 是独立变量。
- Ydt =可变(火炬。张量([[4.0]，[8.0]，[12.0]]):这里我们定义的是变量 Ydt (Ydata)。这里 Ydt 是因变量，这将是我们现在的数据集。
- 类 Linearregressionmodel(torch.nn.Module):模型是 torch . nn . module 的子类。
- self . linear = torch.nn.Linear(1，1): 这里我们有一个 one input，on output 是 torch . nn . linear()函数的自变量。
Model = Linearregressionmodel()用于为线性回归模型创建一个对象。- criterion = torch . nn . ms loss(size _ average = False):这里我们将使用均方误差作为我们的损失函数。
- optimizer = torch . optim . SGD(model . parameters()，lr = 0.01): 这里我们使用随机梯度下降作为我们的优化器，并且我们任意地将学习率固定为 0.01。
- 对于范围(200)中的历元:这里我们出现在我们的训练步骤，在训练期间我们执行以下任务 200 次，并通过传递我们的数据来执行向前传递。
- newvariable =变量(火炬。张量([[6.0]])用于测试我们是否使用我们定义的模型得到正确的结果。测试未知值为 6.0。
- print("predict(训练完模型后)")，Model(newvariable)。【T1 项()】用于打印预测值。
# Importing Libraries
import torch
from torch.autograd import Variable
# Describing the variable
Xdt = Variable(torch.Tensor([[2.0], [4.0], [6.0]]))
Ydt = Variable(torch.Tensor([[4.0], [8.0], [12.0]]))
# Initializing the model and declaring the forward pass
class Linearregressionmodel(torch.nn.Module):
def __init__(self):
super(Linearregressionmodel, self).__init__()
# One input and one output
self.linear = torch.nn.Linear(1, 1)
def forward(self, y):
Ypred = self.linear(y)
return Ypred
# Creating an object for linear regression model
Model = Linearregressionmodel()
# Select optimizerand loss criteria
criterion = torch.nn.MSELoss(size_average = False)
optimizer = torch.optim.SGD(Model.parameters(), lr = 0.01)
# Training the model
for epoch in range(200):
# Forward pass: Compute predicted y by passing x to the model
predy = Model(Xdt)
# Compute and print loss
loss = criterion(predy, Ydt)
# Zero gradients, perform a backward pass, And update the weights.
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('epoch {}, loss {}'.format(epoch, loss.item()))
# Test if getting the correct result using the model
newvariable = Variable(torch.Tensor([[6.0]]))
predy = Model(newvariable)
print("predict (After Train the Model)", Model(newvariable).item())
输出:
运行上面的代码后，我们得到了下面的输出，其中我们可以看到，我们的模型固有地学习输入数据和输出数据之间的关系，而无需显式编程。
PyTorch linear regression from scratch
因此，我们从头开始理解 PyTorch 线性回归。
阅读: PyTorch 提前停止
PyTorch 线性回归数据加载器
在本节中，我们将学习 python 中的 PyTorch 线性回归数据加载器。
在线性回归中，输出标注表示为使用权重和偏差的输入要素的线性函数，这些权重和偏差是模型参数。
代码:
在下面的代码中，首先我们将导入所有必要的库，如 import torch，并将 numpy 作为 np 导入。
- inputvar = np.array([[75，69，45]，[93，90，66]，[89，136，60]，[104，45，39]]，dtype = ' float 32 '):我们在这里加载数据。
input var = torch . from _ numpy(input var)用于将 numpy 数组转换为 torch 张量。print(inputvar)用于打印输入值。- dataset = TensorDataset(input var，targetvar) 用于创建张量数据集。
- weight = torch.randn(2，3，requires_grad=True) 用于使用 torch.randn()函数定义权重变量。
- bias = torch.randn(2，requires_grad=True) 用于通过使用 torch.randn()函数来定义偏差变量。
- 打印(重量)用于打印重量。
- 打印(偏差)用于打印偏差。
preds = model(a)用于打印模型输出。
# Importing libraries
import torch
import numpy as np
# Loading the data
inputvar = np.array([[75, 69, 45],
[93, 90, 66],
[89, 136, 60],
[104, 45, 39]],
dtype='float32')
targetvar = np.array([[66, 80],
[91, 111],
[129, 143],
[32, 47]],
dtype='float32')
# Convert to the torch tensor
inputvar = torch.from_numpy(inputvar)
targetvar = torch.from_numpy(targetvar)
# Print the inputs and outputs
print(inputvar)
print(targetvar)
# Create a tensordataset
from torch.utils.data import TensorDataset
dataset = TensorDataset(inputvar, targetvar)
dataset[:2]
# Using Dataloaders class
from torch.utils.data import DataLoader
batchsiz = 2
trainingloader = DataLoader(dataset, batch_size=batchsiz, shuffle=True)
# Acess the data from the dataloaders
a Batch Sample
for input,tar in trainingloader:
print(input)
print(tar)
break
# Define a set of weights and bias
weight = torch.randn(2, 3, requires_grad=True)
bias = torch.randn(2, requires_grad=True)
print(weight)
print(bias)
# Equation of linear regression
def model(y):
return y @ weight.t() + bias
# Predict the model output
for a,b in trainingloader:
preds = model(a)
print("Prediction is :n",preds)
print("nActual targets is :n",b)
break
输出:
在下面的输出中，您可以看到 PyTorch 线性回归数据加载器计算预测和实际目标，预测和实际目标的值打印在屏幕上。
PyTorch linear regression dataloaders
这就是我们如何使用 Pytorch 线性回归数据加载器来计算预测和实际目标。
PyTorch 线性回归损失
在本节中，我们将了解 python 中的 PyTorch 线性回归损失。
在线性回归中，损失函数用于计算模型的性能以及我们的模型的性能。损失函数也用于改进超参数，使得损失的结果值将更小。
代码:
在下面的代码中，首先我们将导入所有必要的库，如 import torch，import numpy as np。
- def ms loss(predict，targ): 用于定义损失函数。
- difference = predict–targ:这里的均方误差定义了实际值和预测值之差的平方平均值。
- print("n Loss is:"，ms Loss(preds，b)) 用于打印损失。
# Importing libraries
import torch
import numpy as np
# Loading the data
inputvar = np.array([[75, 69, 45],
[93, 90, 66],
[89, 136, 60],
[104, 45, 39]],
dtype='float32')
targetvar = np.array([[66, 80],
[91, 111],
[129, 143],
[32, 47]],
dtype='float32')
# Convert to the torch tensor
inputvar = torch.from_numpy(inputvar)
targetvar = torch.from_numpy(targetvar)
# Print the inputs and outputs
print(inputvar)
print(targetvar)
# Create a tensordataset
from torch.utils.data import TensorDataset
dataset = TensorDataset(inputvar, targetvar)
dataset[:2]
# Using Dataloaders class
from torch.utils.data import DataLoader
batchsiz = 2
trainingloader = DataLoader(dataset, batch_size=batchsiz, shuffle=True)
# Acess the data from the dataloaders
# A Batch Sample
for input,tar in trainingloader:
print(input)
print(tar)
break
# Define a set of weights and bias
weight = torch.randn(2, 3, requires_grad=True)
bias = torch.randn(2, requires_grad=True)
print(weight)
print(bias)
# Equation of linear regression
def model(y):
return y @ weight.t() + bias
# Predict the model output
for a,b in trainingloader:
preds = model(a)
print("Prediction is :n",preds)
print("nActual targets is :n",b)
break
# Defining the loss function
def MSEloss(predict, targ):
difference = predict - targ
return torch.sum(difference * difference)/ difference.numel()
# Calculate the loss
for a,b in trainingloader:
preds = model(a)
print("Predict is :n",preds)
print("n Actual targets is :n",b)
print("n Loss is: ",MSEloss(preds, b))
break
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 线性回归损失值打印在屏幕上。
Pytorch linear regression loss
这样，我们了解了 PyTorch 线性回归损失函数。
PyTorch 线性回归梯度下降
在本节中，我们将学习 python 中的 PyTorch 线性回归梯度下降。
在线性回归中，梯度下降被定义为寻找可微函数的局部最小值的优化算法。
这是一种优化算法，它计算损失函数的梯度，以更新权重和减少损失，并找到损失函数的最小值。
代码:
在下面的代码中，首先我们将导入所有必要的库，如 import torch，import numpy as np。
- loss = ms loss(preds，b) 用于计算损失函数。
loss.backward()用于求损失相对于自变量的梯度。weight -= weight.grad *1e-6用于更新权重。bias -= bias.grad * 1e-6用于更新偏差。
# Importing libraries
import torch
import numpy as np
# Loading the data
inputvar = np.array([[75, 69, 45],
[93, 90, 66],
[89, 136, 60],
[104, 45, 39]],
dtype='float32')
targetvar = np.array([[66, 80],
[91, 111],
[129, 143],
[32, 47]],
dtype='float32')
# Convert to the torch tensor
inputvar = torch.from_numpy(inputvar)
targetvar = torch.from_numpy(targetvar)
# Print the inputs and outputs
print(inputvar)
print(targetvar)
# Create a tensordataset
from torch.utils.data import TensorDataset
dataset = TensorDataset(inputvar, targetvar)
dataset[:2]
# Using Dataloaders class
from torch.utils.data import DataLoader
batchsiz = 2
trainingloader = DataLoader(dataset, batch_size=batchsiz, shuffle=True)
# Acess the data from the dataloaders
# A Batch Sample
for input,tar in trainingloader:
print(input)
print(tar)
break
# Define a set of weights and bias
weight = torch.randn(2, 3, requires_grad=True)
bias = torch.randn(2, requires_grad=True)
print(weight)
print(bias)
# Equation of linear regression
def model(y):
return y @ weight.t() + bias
# Predict the model output
for a,b in trainingloader:
preds = model(a)
print("Prediction is :n",preds)
print("nActual targets is :n",b)
break
# Defining the loss function
def MSEloss(predict, targ):
difference = predict - targ
return torch.sum(difference * difference)/ difference.numel()
# Calculate the loss
for a,b in trainingloader:
preds = model(a)
print("Predict is :n",preds)
print("n Actual targets is :n",b)
print("n Loss is: ",MSEloss(preds, b))
break
# Implementing gradient descent for 20 epochs
epochs = 20
for x in range(epochs):
# Iterate through training dataloader
for a,b in trainingloader:
# Generate Prediction
preds = model(a)
# Get the loss and perform backpropagation
loss = MSEloss(preds, b)
loss.backward()
# Let's update the weights
with torch.no_grad():
weight -= weight.grad *1e-6
bias -= bias.grad * 1e-6
# Set the gradients to zero
weight.grad.zero_()
bias.grad.zero_()
print(f"Epoch {x}/{epochs}: Loss: {loss}")
输出:
在下面的输出中，您可以看到 PyTorch 线性回归梯度下降值打印在屏幕上。
PyTorch linear regression gradient descent
这就是我们如何使用 Pytorch 线性回归梯度下降来计算损失梯度，以更新权重和偏差。
阅读: PyTorch 负载模型+示例
PyTorch 正则化线性回归
在本节中，我们将学习 python 中的 PyTorch 线性回归和正则化。
在初始化优化器期间， weight_decay 参数应用了正则化，并将正则化添加到损失中。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch、import variable from torch . autograded 和 import numpy as num。
- xval = [i for i in range(11)] 用于创建用于训练的虚拟数据。
- 类 Linearregressionmodel(torch.nn.Module):模型是 torch . nn . module 的子类。
- model = linear regression(input dim，outputdim) 用于初始化线性回归模型。
criterion = torch . nn . ms loss()用于计算损失。- optimizer = torch . optim . SGD(model . parameters()、lr=lR) 用于初始化优化器。
- 输入=变量(torch.from_numpy(Xtrain))。(cuda())用于将输入转换为变量。
optimizer.zero_grad()用于清除梯度缓冲区，因为我们不希望任何来自前一个时期的梯度结转，也不希望累积梯度。output = model(input)用于从模型中获取输出。- loss = criterion(output，lbl) 用于获得预测输出的损失。
optimizer.step()用于更新参数。- 打印(' epoch {}，loss {} '。format(epoch，loss . item())用于打印历元和损失值。
# Importing libraries
import torch
from torch.autograd import Variable
import numpy as num
# create dummy data for training
xval = [i for i in range(11)]
Xtrain = num.array(xval, dtype=np.float32)
Xtrain = Xtrain.reshape(-1, 1)
yval = [2*i + 1 for i in xval]
Ytrain = num.array(yval, dtype=np.float32)
Ytrain = Ytrain.reshape(-1, 1)
# Create a model class
class linearRegression(torch.nn.Module):
def __init__(self, inputSize, outputSize):
super(linearRegression, self).__init__()
self.linear = torch.nn.Linear(inputSize, outputSize)
def forward(self, y):
out = self.linear(y)
return out
# Instantiate the model
# takes variable 'x'
inputdim = 1
# takes variable 'y'
outputdim = 1
lR = 0.01
epochs = 80
# Initialize the model
model = linearRegression(inputdim, outputdim)
# For GPU
if torch.cuda.is_available():
model.cuda()
# Define the loss function
criterion = torch.nn.MSELoss()
# Initialize the optimizer
optimizer = torch.optim.SGD(model.parameters(), lr=lR)
# Train our model
for epoch in range(epochs):
# Converting input and label to Variable
if torch.cuda.is_available():
input = Variable(torch.from_numpy(Xtrain).cuda())
label = Variable(torch.from_numpy(Ytrain).cuda())
else:
input = Variable(torch.from_numpy(Xtrain))
lbl = Variable(torch.from_numpy(Ytrain))
# Clear gradient buffers because we don't want any gradient from previous epoch to carry forward, dont want to cummulate gradients
optimizer.zero_grad()
# get output from the model, given the inputs
output = model(input)
# get loss for the predicted output
loss = criterion(output, lbl)
print(loss)
# get gradients w.r.t to parameters
loss.backward()
# update parameters
optimizer.step()
print('epoch {}, loss {}'.format(epoch, loss.item()))
输出:
在下面的输出中，您可以看到屏幕上打印了带有正则化值的 PyTorch 线性回归。
PyTorch linear regression with regularization
至此，我们了解了 PyTorch 正则化线性回归。
PyTorch 线性回归精度
在本节中，我们将学习 python 中的 PyTorch 线性回归精度。
线性回归在因变量和自变量之间建立了线性关系。
准确性被定义为评估模型的过程。准确性是模型预测正确的比例。
代码:
在下面的代码中，首先我们将导入所有必要的库，如 import torch，import torch.nn as nn，import torch vision . transforms as transforms，import torch vision . datasets as dtset。
- trainds = dtset。MNIST(root= '。/data '，train=True，transform=transforms。ToTensor()，download=True) 用于加载数据集。
len(trainds)用于找出训练数据集的长度。numepoch = int(numepoch)用于获取 numepoch 整数值。- 类 Linearregressionmodel(torch.nn.Module):模型是 torch . nn . module 的子类。
- models = Linearregressionmodel(InP dim，outdim) 用于初始化模型类。
- 判据= nn。CrossEntropyLoss() 用于计算输入和目标变量之间的交叉熵损失。
- optimizer = torch . optim . SGD(models . parameters()、lr=l_r) 用于初始化优化器。
print(len(list(models . parameters()))用于打印参数的长度。optimizer . zero _ grad()用于清除渐变。- loss = crimes(outps，lbls) 用于计算损失。
totals += lbls.size(0)用于计算标签总数。- 校正+=(预测= = lbls)。sum() 用作正确预测的总数。
- 打印('迭代次数:{}。损失:{}。准确性:{} '。format(iters，losses.item()，accuracy)) 用于在屏幕上打印迭代。
# Importing libraries
import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision.datasets as dtset
# Loading dataset
trainds = dtset.MNIST(root='./data',
train=True,
transform=transforms.ToTensor(),
download=True)
len(trainds)
testds = dtset.MNIST(root='./data',
train=False,
transform=transforms.ToTensor())
len(testds)
# Instantiate the model class
batchsiz = 100
niter = 2000
numepoch = niter / (len(trainds) / batchsiz)
numepoch = int(numepoch)
numepoch
# Dataloaders
trainloadr = torch.utils.data.DataLoader(dataset=trainds,
batch_size=batchsiz,
shuffle=True)
testloadr = torch.utils.data.DataLoader(dataset=testds,
batch_size=batchsiz,
shuffle=False)
# Create the model class
class Linearregressionmodel(torch.nn.Module):
def __init__(self,inpdim,outdim):
super(Linearregressionmodel, self).__init__()
# One input and one output
self.linear = torch.nn.Linear(inpdim,outdim)
def forward(self, y):
Ypred = self.linear(y)
return Ypred
inpdim = 28*28
outdim = 10
# Initializing the model
models = Linearregressionmodel(inpdim, outdim)
# Define the loss
criterions = nn.CrossEntropyLoss()
l_r = 0.001
# Initialize the optimizer
optimizers = torch.optim.SGD(models.parameters(), lr=l_r)
print(models.parameters())
print(len(list(models.parameters())))
print(list(models.parameters())[0].size())
print(list(models.parameters())[1].size())
# Train the model
iters = 0
for epoch in range(numepoch):
for x, (imgs, lbls) in enumerate(trainloadr):
imgs = imgs.view(-1, 28*28).requires_grad_()
label = lbls
optimizers.zero_grad()
# Forward pass to get output/logits
outps = models(imgs)
losses = criterions(outps, lbls)
losses.backward()
optimizers.step()
iters += 1
if iters % 500 == 0:
corrects = 0
totals = 0
for imgs, lbls in testloadr:
imgs = imgs.view(-1, 28*28).requires_grad_()
outps = models(imgs)
_, predict = torch.max(outps.data, 1)
totals += lbls.size(0)
corrects += (predict == lbls).sum()
accuracy = 100 * corrects / totals
print('Iterations: {}. Loss: {}. Accuracy: {}'.format(iters, losses.item(), accuracy))
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 线性回归精度值打印在屏幕上。
PyTorch linear regression accuracy
这就是我们如何计算 PyTorch 线性回归精度。
另外，看看更多的 Python PyTorch 教程。
- 【numpy 指针为张量
- PyTorch 激活功能
- PyTorch MNIST 教程
- PyTorch 车型总结
- Jax Vs PyTorch【主要区别】
因此，在本教程中，我们讨论了 Pytorch 线性回归,我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch 线性回归
- PyTorch 线性回归从零开始
- PyTorch 线性回归数据加载器
- PyTorch 线性回归损失
- PyTorch 线性回归梯度下降
- 正则化 PyTorch 线性回归
- PyTorch 线性回归精度
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch 负载模型+示例
在这个 Python 教程中，我们将学习 PyTorch 负载模型，我们还将涵盖与 PyTorch 负载模型相关的不同示例。我们将讨论这些话题。
- PyTorch 负荷模型
- PyTorch 负载模型示例
- PyTorch 加载模型检查点
- PyTorch 将模型加载到 GPU
- 用于推理的 PyTorch 负载模型
- PyTorch 负载模型继续培训
- PyTorch 将模型加载到设备
- PyTorch 从 bin 文件加载模型
- 来自 pth 路径的 PyTorch 负载模型
- 没有类的 PyTorch 负载模型
目录
- PyTorch 负荷模型
- PyTorch 负载模型示例
- PyTorch 加载模型检查点
- PyTorch 加载模型到 GPU
- PyTorch 用于推理的负荷模型
- PyTorch 负载模型继续训练
- PyTorch 向设备加载模型
- PyTorch 从 bin 文件加载模型
- 来自 pth 路径的 PyTorch 负载模型
- PyTorch 无类负载模型
PyTorch 负荷模型
在本节中，我们将了解如何用 python 加载 PyTorch 模型。
- PyTorch 加载模型定义为保存数据后加载模型的过程。
- 函数
torch.load()用于加载数据，它是一个解包工具，但处理张量下划线的存储。
语法:
在这种语法中，我们将加载模型的数据。
torch.load(f,map_location=None,pickle_module,pickle_load_args)
参数:
f是一个类似文件的对象，有实现 read()、tell()等或字符串。在类路径对象中保存一个文件名。map_location是标识如何编辑存储位置的函数或字符串。pickle_module用于解包元数据。pickle_load_args被用作可选的关键字参数，该参数传递给 pickle_module.load()。
阅读: PyTorch 批量标准化
PyTorch 负载模型示例
在这一节中，我们将了解如何借助 python 中的示例来加载 PyTorch 模型。
Torch.load() 函数用于加载模型，它是一个非拾取工具，但它处理强调张量的存储。
代码:
在下面的代码中，我们导入了一些库，从中我们可以加载我们的模型。
- nn。MaxPool2d(2，2) 用于应用于从多个输入平面采集的输入信号。
- nn。线性()用于制作前馈网络。
- 优化者= optim。SGD(models.parameters()，lr=0.001，momentum=0.9) 用于初始化模型。
- print(param_tensor，" \t "，models . state _ dict()[param _ tensor]。(size())用于打印模型。
torch.save()用于保存模型。models.load_state_dict()用于加载模型。
import torch
from torch import nn
import torch.optim as optim
import torch.nn.functional as f
**# Define model**
class TheModelClass(nn.Module):
def __init__(self):
super(TheModelClass, self).__init__()
self.conv1 = nn.Conv2d(5, 8, 7)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(8, 18, 7)
self.fc1 = nn.Linear(18 * 7 * 7, 140)
self.fc2 = nn.Linear(140, 86)
self.fc3 = nn.Linear(86, 12)
def forward(self, X):
X = self.pool(F.relu(self.conv1(X)))
X = self.pool(F.relu(self.conv2(X)))
X = x.view(-1, 16 * 5 * 5)
X = f.relu(self.fc1(X))
X = f.relu(self.fc2(X))
X = self.fc3(X)
return X
models = TheModelClass()
**# Initialize optimizer**
optimizers = optim.SGD(models.parameters(), lr=0.001, momentum=0.9)
print("Models state_dict:")
for param_tensor in models.state_dict():
print(param_tensor, "\t", models.state_dict()[param_tensor].size())
print("Optimizers state_dict:")
for var_name in optimizers.state_dict():
print(var_name, "\t", optimizers.state_dict()[var_name])
torch.save(models.state_dict(), 'model_weights.pth')
models.load_state_dict(torch.load('model_weights.pth'))
models.eval()
输出:
运行上述代码后，我们得到以下输出，从中我们可以看到装载模型数据被打印在屏幕上。
PyTorch load model example
PyTorch 加载模型检查点
在本节中，我们将学习 Python 中的 PyTorch 加载模型检查点。
PyTorch 加载模型检查点用于加载模型。为了加载模型，我们可以首先初始化模型，然后加载优化器。
代码:
在下面的代码中，我们将导入一些库，从中可以加载检查点。
- 优化器=优化器。SGD(net.parameters()，lr=0.001，momentum=0.9) 用于初始化优化器。
torch.save()用于保存模型。checkpoint = torch.load()用于加载模型。
import torch
import torch.nn as nn
import torch.optim as optim
class net(nn.Module):
def __init__(self):
super(net, self).__init__()
self.conv1 = nn.Conv2d(5, 8, 7)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(8, 18, 7)
self.fc1 = nn.Linear(18 * 5 * 5, 140)
self.fc2 = nn.Linear(140, 86)
self.fc3 = nn.Linear(86, 12)
def forward(self, X):
X = self.pool(f.relu(self.conv1(X)))
X = self.pool(f.relu(self.conv2(X)))
X = X.view(-1, 16 * 5 * 5)
X = f.relu(self.fc1(X))
X = f.relu(self.fc2(X))
X = self.fc3(X)
return X
netout = net()
print(netout)
optimizers = optim.SGD(netout.parameters(), lr=0.001, momentum=0.9)
**# Additional information**
epoch = 7
path = "model.pt"
loss = 0.6
torch.save({
'epoch': epoch,
'model_state_dict': netout.state_dict(),
'optimizer_state_dict': optimizers.state_dict(),
'loss': loss,
}, path)
models = net()
optimizers = optim.SGD(netout.parameters(), lr=0.001, momentum=0.9)
CheckPoint = torch.load(path)
models.load_state_dict(CheckPoint['model_state_dict'])
optimizers.load_state_dict(CheckPoint['optimizer_state_dict'])
Epoch = CheckPoint['epoch']
Loss = CheckPoint['loss']
models.eval()
输出:
运行上面的代码后，我们得到了下面的输出，其中我们可以看到屏幕上加载了模型检查点。
Pytorch load model checkpoint
PyTorch 加载模型到 GPU
在本节中，我们将学习如何用 Python 将模型加载到 GPU 中。
PyTorch load model to GPU 用于将模型加载到 GPU。首先，我们将初始化数据，初始化后保存数据，然后，我们将加载模型到 GPU。
代码:
在下面的代码中，我们将导入一些库来将我们的模型加载到 GPU。
Path = "model.pt"用于给出我们的模型保存的路径，或者保存后我们可以加载一个模型到这个路径。- torch.save(net.state_dict()，Path) 用于保存模型。
torch.device("cuda")用于设置和运行 cuda 操作。model . load _ state _ dict(torch . load(Path))用于加载模型。
import torch
from torch import nn
from torch import optim
import torch.nn.functional as f
class model(nn.Module):
def __init__(self):
super(model, self).__init__()
self.conv1 = nn.Conv2d(5, 8, 7)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(8, 18, 7)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(140, 86)
self.fc3 = nn.Linear(86, 12)
def forward(self, X):
X = self.pool(f.relu(self.conv1(X)))
X = self.pool(f.relu(self.conv2(X)))
X = x.view(-1, 16 * 5 * 5)
X = f.relu(self.fc1(X))
X = f.relu(self.fc2(X))
X = self.fc3(X)
return X
netout = model()
print(netout)
Path = "model.pt"
**# save**
torch.save(netout.state_dict(), Path)
**# load**
device = torch.device("cuda")
model = model()
model.load_state_dict(torch.load(Path))
model.to(device)
输出:
在下面的代码中，我们在初始化后初始化模型保存我们的模型保存模型后，我们可以再次加载模型，并将模型加载到 GPUdata 显示在屏幕上。
Pytorch load model to gpu
PyTorch 用于推理的负荷模型
在本节中，我们将学习 Python 中用于推理的 PyTorch 加载模型。
PyTorch 推理负荷模型被定义为得出结论的证据和推理。
代码:
在下面的代码中，我们将导入一些库，从中可以加载我们的模型。
- 优化器=优化器。SGD(net.parameters()，lr=0.001，momentum=0.9) 用于初始化优化器。
Path = " state _ dict _ model . pt "用于给出模型的路径。- torch.save(net.state_dict()，Path) 用于保存模型。
model . load _ state _ dict(torch . load(Path))用于加载模型。
import torch
from torch import nn
import torch.optim as optimizer
import torch.nn.functional as f
class net(nn.Module):
def __init__(self):
super(net, self).__init__()
self.conv1 = nn.Conv2d(5, 8, 7)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(8, 18, 7)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(140, 86)
self.fc3 = nn.Linear(86, 12)
def forward(self, X):
X = self.pool(f.relu(self.conv1(x)))
X = self.pool(f.relu(self.conv2(x)))
X = x.view(-1, 16 * 5 * 5)
X = f.relu(self.fc1(X))
X = f.relu(self.fc2(X))
X = self.fc3(X)
return X_test
netoutput = net()
print(netoutput)
optimizer = optimizer.SGD(netoutput.parameters(), lr=0.001, momentum=0.9)
Path = "state_dict_model.pt"
torch.save(netoutput.state_dict(), Path)
model = net()
model.load_state_dict(torch.load(Path))
model.eval()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 负载模型推断数据被打印在屏幕上。
Pytorch load model inference
阅读:张量流得到形状
PyTorch 负载模型继续训练
在本节中，我们将学习 python 中的 PyTorch 负载模型继续培训。
py torch load model continues training 定义为一个持续训练模型并借助 torch.load() 函数加载模型的过程。
代码:
在下面的代码中，我们将导入一些库，我们可以从这些库中加载持续培训模型。
- 优化器= optim。SGD(net.parameters()，lr=0.001，momentum=0.9) 用于初始化优化器。
torch.save()用于保存模型。optimizer . load _ state _ dict()用于加载继续训练模型。model.eval()用于评估模型。
import torch
import torch.nn as nn
import torch.optim as optim
class train_model(nn.Module):
def __init__(self):
super(train_model, self).__init__()
self.conv1 = nn.Conv2d(5, 8, 7)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(8, 18, 7)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(140, 86)
self.fc3 = nn.Linear(86, 12)
def forward(self, X):
X = self.pool(F.relu(self.conv1(X)))
X = self.pool(F.relu(self.conv2(X)))
X = X.view(-1, 16 * 5 * 5)
X = F.relu(self.fc1(X))
X = F.relu(self.fc2(X))
x = self.fc3(X)
return X
netoutput = train_model()
#print(netoutput)
optimizers = optim.SGD(netoutput.parameters(), lr=0.001, momentum=0.9)
epoch = 7
path = "model.pt"
loss = 0.6
torch.save({
'epoch': epoch,
'model_state_dict': netoutput.state_dict(),
'optimizers_state_dict': optimizers.state_dict(),
'loss': loss,
}, path)
models = train_model()
optimizers = optim.SGD(models.parameters(), lr=0.001, momentum=0.9)
CheckPoint = torch.load(path)
models.load_state_dict(CheckPoint['model_state_dict'])
optimizers.load_state_dict(CheckPoint['optimizers_state_dict'])
Epoch = CheckPoint['epoch']
Loss = CheckPoint['loss']
models.eval()
models.train()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到屏幕上加载了继续训练模型。
PyTorch load model continue training
PyTorch 向设备加载模型
在本节中，我们将学习如何用 python 将 PyTorch 模型加载到设备中。
PyTorch load model to the device 用于借助 torch.load() 函数将多个组件加载到设备中。
代码:
在下面的代码中，我们将导入一些库，从这些库中我们可以将模型加载到设备中。
- 优化器=优化器。SGD(netoutput.parameters()，lr=0.001，momentum=0.9) 用于初始化优化器。
Path = " state _ dict _ model . pt "用于指定路径。- torch . save(net output . state _ dict()，Path) 用于将模型保存到 cpu。
models . load _ state _ dict(torch . load(Path))用于加载模型。models.to(device)用于将模型加载到设备中。
import torch
from torch import nn
import torch.optim as optimizer
import torch.nn.functional as f
class Netmodel(nn.Module):
def __init__(self):
super(Netmodel, self).__init__()
self.conv1 = nn.Conv2d(5, 8, 7)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(8, 18, 7)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(140, 86)
self.fc3 = nn.Linear(86, 12)
def forward(self, X):
X = self.pool(f.relu(self.conv1(x)))
X = self.pool(f.relu(self.conv2(x)))
X = x.view(-1, 16 * 5 * 5)
X = f.relu(self.fc1(X))
X = f.relu(self.fc2(X))
X = self.fc3(X)
return X_test
netoutput = Netmodel()
print(netoutput)
optimizer = optimizer.SGD(netoutput.parameters(), lr=0.001, momentum=0.9)
Path = "state_dict_model.pt"
torch.save(netoutput.state_dict(), Path)
device = torch.device("cuda")
models = Netmodel()
models.load_state_dict(torch.load(Path))
models.to(device)
输出:
在下面的输出中，我们可以看到，在训练模型保存模型之后，首先打印训练模型数据，然后加载模型，加载到设备的数据打印在屏幕上。
PyTorch load model to the device
PyTorch 从 bin 文件加载模型
在本节中，我们将学习如何从 python 中的 bin 文件加载 PyTorch 模型。
- 在继续之前，我们应该对 bin 文件有所了解。Bin 文件是二进制文件的压缩形式。
- 二进制文件被定义为一个文件，写在文件中的内容只能由程序员和硬件来解释。
- PyTorch 从 bin 文件加载模型定义为借助
torch.load()函数从 bin 加载模型。
代码:
在下面的代码中，我们将导入一些库，从中我们可以从 bin 文件中加载模型。
- nn。(linear())用于制作前馈网络。
File = "model.pth"用于给出路径。- torch.save(model.state_dict()，File) 用于保存模型。
load model . load _ state _ dict()用于加载模型。
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, ninput_features):
super(Model, self).__init__()
self.linear = nn.Linear(ninput_features, 1)
def forward(self, X):
ypred = torch.sigmoid(self.linear(X))
return ypred
model = Model(ninput_features=8)
for param in model.parameters():
print(param)
File = "model.pth"
torch.save(model.state_dict(), File)
print(model.state_dict())
loadmodel = Model(ninput_features=8)
loadmodel.load_state_dict(torch.load(File)) # it takes the loaded dictionary, not the path file itself
loadmodel.eval()
print(loadmodel.state_dict())
输出:
在下面的输出中，我们可以看到 PyTorch 模型数据从 bin 中加载并打印在屏幕上。
PyTorch load model from the bin file
阅读 PyTorch 逻辑回归
来自 pth 路径的 PyTorch 负载模型
在这一节中，我们将学习如何从 python 中的路径加载py torch 模型。
- PyTorch 从 pth 路径加载模型被定义为一个过程，我们可以借助于一个
torch.load()函数从该过程加载我们的模型。 - PyTorch 常规约定用于使用保存模型。pth 文件扩展名。
代码:
在下面的代码中，我们将导入一些库，从中我们可以从 pth 路径加载模型。
model = ModelClass()用于初始化模型。- 优化者=优化者。SGD(model.parameters()，lr=0.001，momentum=0.9) 用于初始化优化器。
- print(param_tensor，" \t "，model . state _ dict()[param _ tensor]。(size())用于打印模型 state_dict。
- torch.save(model.state_dict()，' model_weights.pth') 用于保存模型。
- model . load _ state _ dict(torch . load(' model _ weights . PTH ')用于加载模型。
model.eval()用于评估模型。
import torch
from torch import nn
import torch.optim as optimizer
import torch.nn.functional as f
**# Define model**
class ModelClass(nn.Module):
def __init__(self):
super(ModelClass, self).__init__()
self.conv1 = nn.Conv2d(5, 8, 7)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(8, 18, 7)
self.fc1 = nn.Linear(18 * 7 * 7, 140)
self.fc2 = nn.Linear(140, 86)
self.fc3 = nn.Linear(86, 12)
def forward(self, X):
X = self.pool(f.relu(self.conv1(X)))
X = self.pool(f.relu(self.conv2(X)))
X = x.view(-1, 16 * 5 * 5)
X = f.relu(self.fc1(X))
X = f.relu(self.fc2(X))
X = self.fc3(X)
return X
model = ModelClass()
optimizers = optimizer.SGD(model.parameters(), lr=0.001, momentum=0.9)
print("Model state_dict:")
for param_tensor in model.state_dict():
print(param_tensor, "\t", model.state_dict()[param_tensor].size())
torch.save(model.state_dict(), 'model_weights.pth')
model.load_state_dict(torch.load('model_weights.pth'))
model.eval()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到模型是从 pth 路径加载到屏幕上的。
Pytorch load model to the device
PyTorch 无类负载模型
在本节中，我们将学习 python 中没有类的 PyTorch 加载模型。
- 正如我们所知，我们可以在函数
torch.load()的帮助下加载我们的 PyTorch 加载模型，而无需类。 - 保存模型后，我们可以加载模型，加载模型是拆包设施和处理存储。
代码:
在下面的代码中，我们将导入 torch 模块，我们可以从该模块加载模型，而无需类。
model = train model(input features = 4)用于初始化模型。File = "model.pth"用于给出文件的路径。- torch.save(模型，文件)用于保存模型。
load _ model = torch . load(File)用于加载模型，不使用类。load_model.eval()用于评估加载的模型。print(param)用于打印加载模型的参数。
import torch
import torch.nn as nn
class trainmodel(nn.Module):
def __init__(self, inputfeatures):
super(trainmodel, self).__init__()
self.linear = nn.Linear(inputfeatures, 1)
def forward(self, X):
y_pred = torch.sigmoid(self.linear(X))
return y_pred
model = trainmodel(inputfeatures=4)
File = "model.pth"
torch.save(model, File)
load_model = torch.load(File)
load_model.eval()
for param in load_model.parameters():
print(param)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到没有类数据的 PyTorch 加载模型被打印在屏幕上。
PyTorch load model without class
因此，在本教程中，我们讨论了 PyTorch 负载模型,我们还讨论了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch 负荷模型
- PyTorch 负载模型示例
- PyTorch 加载模型检查点
- PyTorch 将模型加载到 GPU
- 用于推理的 PyTorch 负载模型
- PyTorch 负载模型继续培训
- PyTorch 将模型加载到设备
- PyTorch 从 bin 文件加载模型
- 来自 pth 路径的 PyTorch 负载模型
- 没有类的 PyTorch 负载模型
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch 逻辑回归
在本 Python 教程中，我们将学习 Python 中的 PyTorch 逻辑回归，我们还将涵盖与 PyTorch 逻辑回归相关的不同示例。我们将讨论这些话题。
- PyTorch 逻辑回归
- PyTorch 逻辑回归 l2
- PyTorch 逻辑回归模型
- PyTorch 逻辑回归准确度
- PyTorch 逻辑回归特征重要性
- PyTorch 逻辑回归损失函数
- PyTorch 逻辑回归分类器
目录
- PyTorch 逻辑回归
- PyTorch 逻辑回归 l2
- PyTorch 逻辑回归模型
- PyTorch 逻辑回归准确度
- PyTorch 逻辑回归特征重要性
- PyTorch 逻辑回归损失函数
- PyTorch 逻辑回归分类器
PyTorch 逻辑回归
在本节中，我们将学习 python 中的 PyTorch 逻辑回归。
逻辑回归定义为表达数据，解释一个因变量二元变量之间关系的过程。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以进行逻辑回归。
models = logistic _ regression()用于定义模型。criteria = torch . nn . BCE loss(size _ average = True)用于计算判据。- optimizer = torch . optim . SGD(models . parameters()、lr=0.01) 用于初始化优化器。
optimizer . zero _ grad()用于优化零梯度。ypred = models(xdata)用于预测模型。- losses = criteria(ypred，ydata) 用于计算损失。
losses.backward()用于计算向后损失。- print("预测 y 值: "，ypred.data[0][0]) 用于打印预测 y 值。
import torch
from torch.autograd import Variable
from torch.nn import functional as f
xdata = Variable(torch.Tensor([[12.0], [11.0], [5.0], [4.0]]))
ydata = Variable(torch.Tensor([[92.0], [82.0], [52.0], [32.0]]))
class logistic_regression(torch.nn.Module):
def __init__(self):
super(logistic_regression, self).__init__()
self.linear = torch.nn.Linear(1, 1)
def forward(self, y):
ypred = f.sigmoid(self.linear(y))
return ypred
models = logistic_regression()
criterions = torch.nn.BCELoss(size_average=True)
optimizers = torch.optim.SGD(models.parameters(), lr=0.01)
for epoch in range(20):
models.train()
optimizers.zero_grad()
**# Forward pass**
ypred = models(xdata)
**# Compute Loss**
losses = criterions(ypred, ydata)
**# Backward pass**
losses.backward()
optimizers.step()
x = Variable(torch.Tensor([[6.0]]))
ypred = models(x)
print("predicted y value: ", ypred.data[0][0])
输出:
运行上面的代码后，我们得到了下面的输出，其中我们可以看到预测的 y 值被打印在屏幕上。
PyTorch logistic regression
PyTorch 逻辑回归 l2
在本节中，我们将学习 python 中的 PyTorch 逻辑回归 l2 。
在初始化优化器期间， weight_decay 参数应用了 l2 正则化，并将正则化添加到损失中。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以找到逻辑回归。
- trainds = dtset。MNIST(root= '。/data '，train=True，transform=transforms。ToTensor()，download=True) 作为训练数据集。
len(trainds)用于查找训练数据集的长度。numepoch = int(numepoch)用于获取 numepoch 整数值。- test loadr = torch . utils . data . data loader(dataset = testds，batch_size=batchsiz，shuffle=False) 用于加载测试数据集。
- 判据= nn。CrossEntropyLoss() 用于计算输入和目标变量之间的交叉熵损失。
- optimizer = torch . optim . SGD(models . parameters()，lr=l_r )用于初始化优化器。
print(len(list(models . parameters()))用于打印参数的长度。- imgs = imgs.view(-1，28*28)。requires_grad_() 用于加载图片作为参数。
optimizer . zero _ grad()用于清除渐变。- loss = crimes(outps，lbls) 用于计算损失。
totals += lbls.size(0)用于计算标签总数。- corrects += (predict == lbls)。sum() 被用作正确预测的总数。
- 打印('迭代次数:{}。损失:{}。准确性:{} '。format(iters，losses.item()，accuracy)) 用于在屏幕上打印迭代。
import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision.datasets as dtset
trainds = dtset.MNIST(root='./data',
train=True,
transform=transforms.ToTensor(),
download=True)
len(trainds)
testds = dtset.MNIST(root='./data',
train=False,
transform=transforms.ToTensor())
len(testds)
batchsiz = 100
niter = 2000
numepoch = niter / (len(trainds) / batchsiz)
numepoch = int(numepoch)
numepoch
trainloadr = torch.utils.data.DataLoader(dataset=trainds,
batch_size=batchsiz,
shuffle=True)
testloadr = torch.utils.data.DataLoader(dataset=testds,
batch_size=batchsiz,
shuffle=False)
class logistic_regression(nn.Module):
def __init__(self, inpdim, outpdim):
super(logistic_regression, self).__init__()
self.linear = nn.Linear(inpdim, outdim)
def forward(self, y):
outp = self.linear(y)
return outp
inpdim = 28*28
outdim = 10
models = logistic_regression(inpdim, outdim)
criterions = nn.CrossEntropyLoss()
l_r = 0.001
optimizers = torch.optim.SGD(models.parameters(), lr=l_r)
print(models.parameters())
print(len(list(models.parameters())))
print(list(models.parameters())[0].size())
print(list(models.parameters())[1].size())
iters = 0
for epoch in range(numepoch):
for x, (imgs, lbls) in enumerate(trainloadr):
imgs = imgs.view(-1, 28*28).requires_grad_()
label = lbls
optimizers.zero_grad()
**# Forward pass to get output/logits**
outps = models(imgs)
losses = criterions(outps, lbls)
losses.backward()
optimizers.step()
iters += 1
if iters % 500 == 0:
corrects = 0
totals = 0
for imgs, lbls in testloadr:
imgs = imgs.view(-1, 28*28).requires_grad_()
outps = models(imgs)
_, predict = torch.max(outps.data, 1)
totals += lbls.size(0)
corrects += (predict == lbls).sum()
accuracy = 100 * corrects / totals
print('Iterations: {}. Loss: {}. Accuracy: {}'.format(iters, losses.item(), accuracy))
输出:
运行上面的代码后，我们得到下面的输出，可以看到屏幕上显示了损耗和精度。
PyTorch logistic regression l2
PyTorch 逻辑回归模型
在本节中，我们将学习 python 中使用 mnist 数据的 PyTorch 逻辑回归。
逻辑回归用于表达数据，也用于阐明一个因变量之间的关系。在这里，我们可以使用 mnist 数据集来计算回归。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以进行逻辑回归。
- datasets = fashion mnist(root = ' D:\ py torch \ data '，train=True，transform=transforms。ToTensor()，download=True) 作为数据集使用。
- traindatas，valdatas = random_split(datasets，[50000，10000]) 用于训练和验证数据。
- test datas = fashion mnist(root = ' D:\ py torch \ data '，train=False，transform=transforms。【ToTensor()】用于测试数据。
- train loadr = data loader(train datas，batchsiz，shuffle=True) 用于加载列车数据。
- valloadr = data loader(valdatas，batchsiz*2) 用于验证数据。
outp = self(imgs)用于生成预测。- losses = fun . cross _ entropy(outp，lbls) 用于计算损失。
- accur = accuracy(outp，lbls) 用于计算精度。
- epochloss = torch . stack(batchlosses)。平均值()用于组合损失。
- epochaccu = torch . stack(batchaccus)。mean() 用于组合精度。
- eval(modl，valloadr) 用于评估模型。
import torch
import torchvision
import torch.nn as nn
import matplotlib.pyplot as plot
import torch.nn.functional as fun
import torchvision.transforms as transforms
from torchvision.datasets import FashionMNIST
from torch.utils.data import random_split
from torch.utils.data import DataLoader
import numpy as num
batchsiz = 124
lr = 0.001
inputsiz = 28*28
numclass = 12
datasets = FashionMNIST(root='D:\PyTorch\data', train=True, transform=transforms.ToTensor(), download=True)
traindatas, valdatas = random_split(datasets, [50000, 10000])
testdatas = FashionMNIST(root='D:\PyTorch\data', train=False, transform=transforms.ToTensor())
**# Dataloaders**
trainloadr = DataLoader(traindatas, batchsiz, shuffle=True)
valloadr = DataLoader(valdatas, batchsiz*2)
testloadr = DataLoader(testdatas, batchsiz*2)
class mnistmodel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(inputsiz, numclass)
def forward(self, ya):
ya = ya.reshape(-1, 784)
outp = self.linear(ya)
return outp
def train(self, batches):
imgs, lbls = batches
outp = self(imgs)
losses = fun.cross_entropy(outp, lbls)
return losses
def validate(self, batches):
imgs, lbls = batches
outp = self(imgs)
losses = fun.cross_entropy(outp, lbls)
accur = accuracy(outp, lbls)
return {'valloss': losses.detach(), 'valacc': accur.detach()}
def validationepoch_end(self, outpts):
batchlosses = [y['valloss'] for y in outpts]
epochloss = torch.stack(batchlosses).mean()
batchaccus = [y['valacc'] for y in outpts]
epochaccu = torch.stack(batchaccus).mean()
return {'valloss': epochloss.item(), 'valacc': epochaccu.item()}
def epochend(self, epoch, result):
print("Epoch [{}], valloss: {:.4f}, valacc: {:.4f}".format(epoch, result['valloss'], result['valacc']))
modl = mnistmodel()
def accuracy(outpts, lbls):
_, pred = torch.max(outpts, dim=1)
return torch.tensor(torch.sum(pred == lbls).item() / len(pred))
def eval(modl, valloadr):
outpts = [modl.validate(batch) for batch in valloadr]
return modl.validationepoch_end(outpts)
def fit(epoch, lr, modl, trainloadr, valloadr, optfunc=torch.optim.SGD):
history = []
optimizers = optfunc(modl.parameters(), lr)
for epoch in range(epoch):
**# Training Phase**
for batch in trainloadr:
loss = modl.training_step(batch)
loss.backward()
optimizers.step()
optimizers.zero_grad()
** # Validation phase**
result = eval(modl, valloadr)
modl.epoch_end(epoch, result)
history.append(result)
return history
eval(modl, valloadr)
输出:
在下面的输出中，我们可以看到在评估模型之后，经验证的准确性分数被打印在屏幕上。
PyTorch logistic regression mnist
PyTorch 逻辑回归准确度
在本节中，我们将学习如何在 python 中计算逻辑回归的精确度。
逻辑回归是一种用于预测二元类和计算事件发生概率的静态方法。
准确度被定义为正确预测占总预测的比例，这里我们可以计算逻辑回归的准确度。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以计算模型的精度。
- traindatast = dsets。MNIST(root = '。/data '，train = True，transform = transforms。ToTensor()，download = True) 作为训练数据集。
- train ldr = torch . utils . data . data loader(dataset = train datast，batch_size = batchsiz，shuffle = True) 用作数据集加载器。
- modl = logistic_reg(inputsiz，numclss)用于定义为 logistic 回归模型。
- optimiz = torch . optim . SGD(modl . parameters()、lr = l_r) 用于初始化优化器。
- print('测试图像上模型的精度:% d %%' % (100 * corct / totls)) 用于打印模型的精度。
import torch
import torch.nn as nn
import torchvision.datasets as dsets
import torchvision.transforms as transforms
from torch.autograd import Variable
**# Hyper Parameters**
inputsiz = 784
numclsses = 10
numepoch = 3
batchsiz = 98
l_r = 0.001
traindatast = dsets.MNIST(root ='./data',
train = True,
transform = transforms.ToTensor(),
download = True)
testdatast = dsets.MNIST(root ='./data',
train = False,
transform = transforms.ToTensor())
trainldr = torch.utils.data.DataLoader(dataset = traindatast,
batch_size = batchsiz,
shuffle = True)
testldr = torch.utils.data.DataLoader(dataset = testdatast,
batch_size = batchsiz,
shuffle = False)
class logistic_reg(nn.Module):
def __init__(self, inputsiz, numclsses):
super(logistic_reg, self).__init__()
self.linear = nn.Linear(inputsiz, numclsses)
def forward(self, y):
outp = self.linear(y)
return outp
modl = logistic_reg(inputsiz, numclsses)
critrion = nn.CrossEntropyLoss()
optimiz = torch.optim.SGD(modl.parameters(), lr = l_r)
**# Training the Model**
for epoch in range(numepoch):
for a, (imgs, lbls) in enumerate(trainldr):
imgs = Variable(imgs.view(-1, 28 * 28))
lbls = Variable(lbls)
optimiz.zero_grad()
output = modl(imgs)
losses = critrion(output, lbls)
losses.backward()
optimiz.step()
**# Test the Model**
corct = 0
totls = 0
for imgs, lbls in testldr:
imgs = Variable(imgs.view(-1, 28 * 28))
output = modl(imgs)
_, predict = torch.max(output.data, 1)
totls += lbls.size(0)
corct += (predict == lbls).sum()
print('Accuracy Of The Model on the test images: % d %%' % (
100 * corct / totls))
输出:
运行上面的代码后，我们得到了下面的输出，其中我们可以看到模型的准确性被打印在屏幕上。
PyTorch logistic regression accuracy
阅读: PyTorch 批量标准化
PyTorch 逻辑回归特征重要性
在本节中，我们将了解 PyTorch 逻辑回归特性的重要性。
逻辑回归中的特征重要性是建立模型和描述现有模型的常用方法。
代码:
在下面的代码中，我们将导入一些模块，从中我们可以描述现有的模型。
- modl = logistic_regr(indim，outdim) 用于实例化模型类。
- optim = torch . optim . SGD(modl . parameters()、lr=l_r) 用于实例化优化器。
- critr = nn。CrossEntropyLoss() 用于实例化损失类。
- imags = imags.view(-1，28*28)。requires_grad_() 用于加载图像作为变量。
- _，predicted = torch.max(outs.data，1) 用于从最大值得到预测值。
ttl += labls.size(0)用于计算变量总数。- crct +=(预测== labls)。sum() 用于计算正确预测的总数。
import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision.datasets as dtsets
traindt = dtsets.MNIST(root='./data',
train=True,
transform=transforms.ToTensor(),
download=True)
testdt = dtsets.MNIST(root='./data',
train=False,
transform=transforms.ToTensor())
bsize = 100
niterations = 3000
epoch = niterations / (len(traindt) / bsize)
epoch = int(epoch)
trainlr = torch.utils.data.DataLoader(dataset=traindt,
batch_size=bsize,
shuffle=True)
testlr = torch.utils.data.DataLoader(dataset=testdt,
batch_size=bsize,
shuffle=False)
class logistic_regr(nn.Module):
def __init__(self, insize, numclass):
super(logistic_regr, self).__init__()
self.linear = nn.Linear(indim, outdim)
def forward(self, y):
outs = self.linear(y)
return outs
indim = 28*28
outdim = 10
modl = logistic_regr(indim, outdim)
critr = nn.CrossEntropyLoss()
l_r = 0.001
optim = torch.optim.SGD(modl.parameters(), lr=l_r)
iterations = 0
for epoch in range(epoch):
for a, (imags, labls) in enumerate(trainlr):
imags = imags.view(-1, 28*28).requires_grad_()
labls = labls
optim.zero_grad()
outs = modl(imags)
loss = critr(outs, labls)
loss.backward()
optim.step()
iterations += 1
if iterations % 500 == 0:
crct = 0
ttl = 0
for imags, labls in testlr:
imags = imags.view(-1, 28*28).requires_grad_()
outs = modl(imags)
_, predicted = torch.max(outs.data, 1)
ttl += labls.size(0)
crct += (predicted == labls).sum()
accur = 100 * crct.item() / ttl
print(' Accuracy: {}'.format( accur))
输出:
运行上面的代码后，我们得到下面的输出，从中我们可以看到我们可以建立一个模型，并获得模型的准确性。
PyTorch logistic regression feature importance
阅读: PyTorch 负载模型+示例
PyTorch 逻辑回归损失函数
在本节中，我们将学习 python 中的 PyTorch 逻辑回归损失函数。
逻辑回归的损失函数是对数损失。从目标和预测中依次计算损失函数，以更新最佳模型选择的权重。
代码:
在下面的代码中，我们将导入一些 torch 模块，从中我们可以计算损失函数。
- traindst = dsets。MNIST(root= '。/data '，train=True，transform=transforms。ToTensor()，download=True) 用作训练数据集。
- train ldr = torch . utils . data . data loader(dataset = train dst，batch_size=batchsiz，shuffle=True) 用于加载列车数据。
- models = logistic _ regression(input dims，outputdims) 用于创建 logistic 回归模型。
criteria = torch . nn . crossentropyloss()用于计算损失。- optimizer = torch . optim . SGD(models . parameters()、lr=l_r) 用于初始化优化器。
optimizer . zero _ grad()用于优化零梯度。- 精度= 100 *总数/总数用于计算精度。
- 打印("迭代:{}。损失:{}。"。(ITER，losses.item())【格式】用于打印损失。
import torch
from torch.autograd import Variable
import torchvision.transforms as transforms
import torchvision.datasets as dsets
batchsiz = 100
niter = 3000
inputdims = 784
outputdims = 10
l_r = 0.001
traindst = dsets.MNIST(root='./data', train=True, transform=transforms.ToTensor(), download=True)
testdst = dsets.MNIST(root='./data', train=False, transform=transforms.ToTensor())
trainldr = torch.utils.data.DataLoader(dataset=traindst, batch_size=batchsiz, shuffle=True)
testldr = torch.utils.data.DataLoader(dataset=testdst, batch_size=batchsiz, shuffle=False)
epoch = niter / (len(traindst) / batchsiz)
class logistic_regression(torch.nn.Module):
def __init__(self, inputdims, outputdims):
super(logistic_regression, self).__init__()
self.linear = torch.nn.Linear(inputdims, outputdims)
def forward(self, y):
out = self.linear(y)
return out
models = logistic_regression(inputdims, outputdims)
criterions = torch.nn.CrossEntropyLoss()
optimizers = torch.optim.SGD(models.parameters(), lr=l_r)
iter = 0
for epoch in range(int(epoch)):
for x, (imgs, lbls) in enumerate(trainldr):
imgs = Variable(imgs.view(-1, 28 * 28))
lbls = Variable(lbls)
optimizers.zero_grad()
out = models(imgs)
losses = criterions(out, lbls)
losses.backward()
optimizers.step()
iter+=1
if iter%500==0:
crrects = 0
totals = 0
for imgs, lbls in testldr:
imgs = Variable(imgs.view(-1, 28*28))
out = models(imgs)
_, predicted = torch.max(out.data, 1)
totals+= lbls.size(0)
crrects+= (predicted == lbls).sum()
accuracy = 100 * crrects/totals
print("Iteration: {}. Loss: {}.".format(iter, losses.item()))
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到屏幕上显示了损失值。
PyTorch logistic regression loss function
PyTorch 逻辑回归分类器
在本节中，我们将学习 python 中的 PyTorch 逻辑回归分类器。
逻辑回归分类器用于解释数据和定义独立二元变量之间的关系。
代码:
在下面的代码中，我们将导入一些模块，从中我们可以计算逻辑回归分类器。
models = logistic _ regression()用于创建模型。criteria = torch . nn . BCE loss(size _ average = True)用于计算判据。- optimizer = torch . optim . SGD(models . parameters()、lr=0.01) 用于初始化优化器。
optimizer . zero _ grad()用于优化零梯度。zpred = models(xdt)用于预测模型。- nwx =可变(火炬。张量([[6.0]])用于创建新变量。
zpred = models(nwx)用于预测新模型。- print("预测 y 值: "，zpred.data[0][0]) 用于预测 y 值。
import torch
from torch.autograd import Variable
from torch.nn import functional as f
xdt = Variable(torch.Tensor([[15.0], [12.0]]))
ydt = Variable(torch.Tensor([[92.0], [82.0]]))
class logistic_regression(torch.nn.Module):
def __init__(self):
super(logistic_regression, self).__init__()
self.linear = torch.nn.Linear(1, 1)
def forward(self, y):
zpred = f.sigmoid(self.linear(y))
return zpred
models = logistic_regression()
criterions = torch.nn.BCELoss(size_average=True)
optimizers = torch.optim.SGD(models.parameters(), lr=0.01)
for epoch in range(25):
models.train()
optimizers.zero_grad()
zpred = models(xdt)
losses = criterions(zpred, ydt)
losses.backward()
optimizers.step()
nwx = Variable(torch.Tensor([[6.0]]))
zpred = models(nwx)
print("predicted y value: ", zpred.data[0][0])
输出:
在下面的输出中，我们可以看到计算了逻辑回归分类器，并在屏幕上打印了 y 的预测值。
PyTorch logistic regression classifier
你可能也喜欢阅读下面的 PyTorch 教程。
- 交叉熵损失 PyTorch
- pytorch league relu
- PyTorch 整形张量
- PyTorch nn 线性+示例
- PyTorch 车型总结
- 【numpy 指针为张量
- PyTorch 保存模型–完整指南
因此，在本教程中，我们讨论了 PyTorch 逻辑回归,我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch 逻辑回归
- PyTorch 逻辑回归 l2
- PyTorch 逻辑回归模型
- PyTorch 逻辑回归准确度
- PyTorch 逻辑回归特征重要性
- PyTorch 逻辑回归损失函数
- PyTorch 逻辑回归分类器
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch MNIST 教程
在这个 Python 教程中，我们将学习 Python 中的 PyTorch MNIST ，我们还将涵盖与 PyTorch Minist 相关的不同示例。我们将讨论这些话题。
- 皮托奇·姆尼斯特
- PyTorch mnist 示例
- PyTorch mnist 分类
- 皮托奇赔偿 cnn
- PyTorch mnist 数据集
- PyTorch mnist 培训
- 皮托奇·蒙特斯特时尚
- PyTorch 赔偿负荷
- PyTorch 最大精确度
目录
- PyTorch 赔偿
- PyTorch MNIST 的例子
- PyTorch MNIST 分类
- PyTorch 赔偿 CNN
- PyTorch MNIST 数据集
- PyTorch MNIST 培训
- PyTorch MNIST 时尚
- PyTorch 补偿负荷
- PyTorch MNIST 精度
PyTorch 赔偿
在这一节中，我们将学习 python 中的 PyTorch minist 如何工作。
代表 改进型国家标准技术研究院 数据库，是一个手写数字的大型数据库，主要用于训练各种处理系统。
**语法:
datasets.MNIST(root='./data', train=False, download=True, transform=None)
参数:
root用于给存储数据库的数据库赋予根。train = Falsetrain 参数被设置为 False，因为我们想要测试集，而不是训练集。download = Truedownload 被设置为 True，因为我们想要下载数据集。transform=None因为没有数据转换，所以转换参数设置为 None。
同样，检查: PyTorch 二元交叉熵
PyTorch MNIST 的例子
在本节中，我们将通过一个例子来了解如何实现 PyTorch mnist 数据。
MNIST 是一个大型数据库，主要用于训练各种处理系统。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以看到屏幕上加载了 mnist 数据库。
- dts。使用 MNIST(root = 'data '，train = True，transform = ToTensor()，download = True，)作为训练数据集。
- dts。使用 MNIST(root = 'data '，train = False，transform = ToTensor()) 作为测试数据集。
from torchvision import datasets as dts
from torchvision.transforms import ToTensor
traindt = dts.MNIST(
root = 'data',
train = True,
transform = ToTensor(),
download = True,
)
testdt = dts.MNIST(
root = 'data',
train = False,
transform = ToTensor()
)
输出:
运行上面的代码后，我们得到了下面的输出，其中我们可以看到屏幕上下载了 mnist 数据集。
PyTorch Mnist example
阅读: PyTorch 逻辑回归
PyTorch MNIST 分类
在本节中，我们将学习 python 中的 PyTorch mnist 分类。
MNIST 数据库一般用于训练和测试机器学习领域的数据。
代码:
在下面的代码中，我们将导入 torch 库，从中我们可以获得 mnist 分类。
- mnisttrainset = dts。MNIST(root= '。/data '，train=True，download=True，transform = trtransform)作为 mnist 训练数据集。
- train ldr = trch . utils . data . data loader(mnisttrainset，batch_size=10，shuffle=True) 用于加载数据。
- nn。线性()用作有输入输出的前馈网络。
cmodel = classicationmodel()用作分类模型。print(cmodel)用于打印模型。
import torch as trch
import torchvision.datasets as dts
import torchvision.transforms as trnsfrms
import torch.nn as nn
import matplotlib.pyplot as plot
trnsform = trnsfrms.Compose([trnsfrms.ToTensor(), trnsfrms.Normalize((0.7,), (0.7,)),])
mnisttrainset = dts.MNIST(root='./data', train=True, download=True, transform=trnsform)
trainldr = trch.utils.data.DataLoader(mnisttrainset, batch_size=10, shuffle=True)
mnist_testset = dts.MNIST(root='./data', train=False, download=True, transform=trnsform)
testldr = trch.utils.data.DataLoader(mnist_testset, batch_size=10, shuffle=True)
trnsform = trnsfrms.Compose([trnsfrms.ToTensor(), trnsfrms.Normalize((0.7,), (0.7,)),])
class classicationmodel(nn.Module):
def __init__(self):
super( classicationmodel,self).__init__()
self.linear1 = nn.Linear(28*28, 100)
self.linear2 = nn.Linear(100, 50)
self.final = nn.Linear(50, 10)
self.relu = nn.ReLU()
def forward(self, image):
a = image.view(-1, 28*28)
a = self.relu(self.linear1(a))
a = self.relu(self.linear2(a))
a = self.final(a)
return a
cmodel = classicationmodel()
print(cmodel)
输出:
在下面的输出中，我们可以看到 PyTorch mnist 分类数据被打印在屏幕上。
PyTorch Mnist classification
Read: Keras Vs PyTorch
PyTorch 赔偿 CNN
在这一节中，我们将学习 python 中的 PyTorch MNIST CNN 数据。
CNN 代表卷积神经网络，是识别中最常用的一种人工神经网络。
代码:
在下面的代码中，我们将导入一些 torch 模块，从中我们可以获得 CNN 数据。
- dts。MNIST() 被用作数据集。
- nn。Sequential() 在我们想要按顺序运行某些层时使用。
- nn。MaxPool2d() 被用作由输入平面组成的应用输入信号。
outp = self.out(a)用于得到模型的输出。CNN = cnn()用作 CNN 模型。- 打印(CNN) 用于打印 CNN 模型。
from torchvision import datasets as dts
from torchvision.transforms import ToTensor
traindt = dts.MNIST(
root = 'data',
train = True,
transform = ToTensor(),
download = True,
)
testdt = dts.MNIST(
root = 'data',
train = False,
transform = ToTensor()
)
import torch.nn as nn
class cnn(nn.Module):
def __init__(self):
super(cnn, self).__init__()
self.conv = nn.Sequential(
nn.Conv2d(
in_channels=3,
out_channels=18,
kernel_size=7,
stride=3,
padding=4,
),
nn.ReLU(),
nn.MaxPool2d(kernel_size=4),
)
self.conv1 = nn.Sequential(
nn.Conv2d(18, 34, 7, 3, 4),
nn.ReLU(),
nn.MaxPool2d(2),
)
self.out = nn.Linear(34 * 9 * 9, 12)
def forward(self, a):
a = self.conv1(a)
a = self.conv2(a)
a = a.view(a.size(0), -1)
outp = self.out(a)
return outp, a
CNN = cnn()
print(CNN)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch mnist CNN 模型数据被打印在屏幕上。
PyTorch mnist CNN
PyTorch MNIST 数据集
在本节中，我们将了解 Python 中的 PyTorch MNIST 数据集作品。
MNIST 数据集被称为修改的T4 国家标准与技术研究院数据集。它主要用于使用深度学习模型的文本分类。
语法:
MNIST 数据集的以下语法:
torchvision.datasets.MNIST(root: str, train: bool = True , transform = None, target_transform = None, download: bool = False)
参数:
root是 mnist 数据集所在的目录。- train: 如果为真，则创建数据集。
- 下载:如果为真，则从网上下载数据集，放入根目录。
- 转换接收 PIL 图像并返回一个转换后的版本。
- target_transform: 接受目标并对其进行转换的函数。
PyTorch MNIST 培训
在本节中，我们将了解如何使用 python 中的 PyTorch MNIST 数据集来训练数据。
MNIST 数据集用于用训练数据训练模型，用测试数据评估模型。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以用训练数据训练模型。
- trains = torch vision . datasets . Mn ist(root = '。/data '，train=True，transform=trans。ToTensor()，download=True) 用于导入 mnist 数据集。
- train ldr = torch . utils . data . DataLoader(dataset = trains，batch_size=bachsiz，shuffle=True) 用于在 data loader 的帮助下加载数据。
- nn。线性()用于创建带有输入和输出的前馈神经网络。
- optim = torch . optim . Adam(modl . parameters()、lr=l_r) 用于初始化优化器。
- losses = criter(outp，lbls) 用于创建亏损。
- print(f ' epochs[{ epoch+1 }/{ numepchs }]，Step[{x+1}/{nttlstps}]，Losses:{ Losses . item():. 4f } ')用于在屏幕上打印 epoch 和 Losses。
import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as trans
import matplotlib.pyplot as plot
inpsiz = 784
hidensiz = 500
numclases = 10
numepchs = 4
bachsiz = 100
l_r = 0.001
trainds = torchvision.datasets.MNIST(root='./data',
train=True,
transform=trans.ToTensor(),
download=True)
testds = torchvision.datasets.MNIST(root='./data',
train=False,
transform=trans.ToTensor())
trainldr = torch.utils.data.DataLoader(dataset=trainds,
batch_size=bachsiz,
shuffle=True)
testldr = torch.utils.data.DataLoader(dataset=testds,
batch_size=bachsiz,
shuffle=False)
class neural_network(nn.Module):
def __init__(self, inpsiz, hidensiz, numclases):
super(neural_network, self).__init__()
self.inputsiz = inpsiz
self.l1 = nn.Linear(inpsiz, hidensiz)
self.relu = nn.ReLU()
self.l2 = nn.Linear(hidensiz, numclases)
def forward(self, y):
outp = self.l1(y)
outp = self.relu(outp)
outp = self.l2(outp)
return outp
modl = neural_network(inpsiz, hidensiz, numclases)
criter = nn.CrossEntropyLoss()
optim = torch.optim.Adam(modl.parameters(), lr=l_r)
nttlstps = len(trainldr)
for epoch in range(numepchs):
for x, (imgs, lbls) in enumerate(trainldr):
imgs = imgs.reshape(-1, 28*28)
labls = lbls
outp = modl(imgs)
losses = criter(outp, lbls)
optim.zero_grad()
losses.backward()
optim.step()
if (x+1) % 100 == 0:
print (f'Epochs [{epoch+1}/{numepchs}], Step[{x+1}/{nttlstps}], Losses: {losses.item():.4f}')
输出:
运行上面的代码后，我们得到下面的输出，可以看到 epoch 和 losses 被打印在屏幕上。
PyTorch mnist training
阅读: PyTorch 批量标准化
PyTorch MNIST 时尚
在这一节中，我们将学习 python 中的 PyTorch mnist 风格。
时尚 MNIST 数据集用于计算机视觉，也用于评估用于分类的深度神经网络。
语法:
以下是时尚 MNIST 的语法，其中 torchvision 已经有了时尚 MNIST 数据集。
torchvision.datasets.FashionMNIST(root: str, train: bool = True, transform = None, traget_transform = None, download: bool = False)
参数:
root存储我们 FashionMNIST 数据集的根目录。- 训练如果为真，则创建数据集。
transform该函数接收 PIL 图像并返回一个变换版本。target_transform该函数接收目标并对其进行转换。- 下载如果为真，则下载数据集并将其放入根目录。
阅读: PyTorch 负载模型+示例
PyTorch 补偿负荷
在这一节中，我们将学习如何用 python 加载 mnist 数据集。
在这里，我们可以从 PyTorch torchvision 加载 MNIST 数据集。 MNIST 数据集用于用训练数据训练模型，用测试数据评估模型。
代码:
在下面的代码中，我们将导入 torch 模块，从中可以加载 mnist 数据集。
- 数据集。MNIST(root= '。/data '，train=True，transform=trans。ToTensor()，download=True) 用于初始化训练数据集。
- testdt=dtsets。MNIST(root= '。/data '，train=False，transform=trans。ToTensor()，download= True) 用于初始化测试数据集。
import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as trans
from torchvision import datasets as dtsets
traindt = dtsets.MNIST(root='./data',
train=True,
transform=trans.ToTensor(),
download=True)
testdt = dtsets.MNIST(root='./data',
train=False,
transform=trans.ToTensor(),download=True)
输出:
运行上述代码后，我们得到以下输出，从中可以看到 MNIST 数据集已加载到屏幕上。
PyTorch mnist load
阅读: PyTorch nn 线性+例题
PyTorch MNIST 精度
在本节中，我们将学习 python 中的 PyTorch mnist 精度。
PyTorch mnist 是用于训练和测试模型并获得模型准确性的大量数据。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以计算模型的准确性。
- 数据集。FashionMNIST() 作为数据集使用。
- nn。Sequential() 在我们想要按顺序运行某些层时使用。
- nn。MaxPool2d() 适用于由几个输入平面组成的一个输入信号。
- optim = optim。Adam(Cnn.parameters()，lr = 0.01) 用于初始化优化器。
ax = var(imgs)用于给出批量数据。loss . backward()用作反向传播。- predicy = torch.max(testoutp，1)[1].data.squeeze() 用于预测 y 值。
- accu = (predicy == lbls)。sum()。item() / float(lbls.size(0)) 用于计算精度。
- print('模型精度%.2f' % accu) 用于打印模型精度。
import torch
from torchvision import datasets
from torchvision.transforms import ToTensor
traindt = datasets.FashionMNIST(
root = 'data',
train = True,
transform = ToTensor(),
download = True,
)
testdt = datasets.FashionMNIST(
root = 'data',
train = False,
transform = ToTensor()
)
from torch.utils.data import DataLoader
ldrs = {
'train' : torch.utils.data.DataLoader(traindt,
batch_size=80,
shuffle=True,
num_workers=1),
'test' : torch.utils.data.DataLoader(test_data,
batch_size=80,
shuffle=True,
num_workers=1),
}
import torch.nn as nn
class cnn(nn.Module):
def __init__(self):
super(cnn, self).__init__()
self.conv = nn.Sequential(
nn.Conv2d(
in_channels=1,
out_channels=16,
kernel_size=5,
stride=1,
padding=2,
),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2),
)
self.conv1 = nn.Sequential(
nn.Conv2d(16, 32, 5, 1, 2),
nn.ReLU(),
nn.MaxPool2d(2),
)
self.out = nn.Linear(32 * 7 * 7, 10)
def forward(self, y):
y = self.conv(y)
y = self.conv1(y)
y = y.view(y.size(0), -1)
outp = self.out(y)
return outp, y
Cnn = cnn()
lossfunct = nn.CrossEntropyLoss()
from torch import optim
optim = optim.Adam(Cnn.parameters(), lr = 0.01)
from torch.autograd import Variable as var
numepch = 3
def train(numepchs, Cnn, ldrs):
Cnn.train()
** # Train the model**
ttlstp = len(ldrs['train'])
for epoch in range(numepchs):
for a, (imgs, lbls) in enumerate(ldrs['train']):
ax = var(imgs)
ay = var(lbls)
outp = Cnn(ax)[0]
losses = lossfunct(outp, ay)
optim.zero_grad()
losses.backward()
optim.step()
if (a+1) % 100 == 0:
print ('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'
.format(epoch + 1, numepchs, i + 1, ttlstp, losses.item()))
def test():
**# Test the model**
Cnn.eval()
with torch.no_grad():
corct = 0
ttl = 0
for imgs, lbls in ldrs['test']:
testoutp, lstlayr = Cnn(imgs)
predicy = torch.max(testoutp, 1)[1].data.squeeze()
accu = (predicy == lbls).sum().item() / float(lbls.size(0))
pass
print(' Accuracy of the model %.2f' % accu)
test()
输出:
在下面的输出中，我们可以看到模型的精度显示在屏幕上。
PyTorch mnist accuracy
另外，再看看一些 PyTorch 教程。
因此，在本教程中，我们讨论了 PyTorch Minist ,我们还讨论了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- 皮托奇·姆尼斯特
- PyTorch mnist 示例
- PyTorch mnist 分类
- 皮托奇赔偿 cnn
- PyTorch mnist 数据集
- PyTorch mnist 培训
- 皮托奇·蒙特斯特时尚
- PyTorch 赔偿负荷
- PyTorch 最大精确度
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch 模型评估+示例
在本 Python 教程中，我们将学习 Python 中的 PyTorch 模型评估，我们还将涵盖与评估模型相关的不同示例。此外，我们将涵盖这些主题。
- PyTorch 模型评估
- PyTorch 模型评估训练
- PyTorch 模型评估
- PyTorch 模型评估与培训
- PyTorch 模型评估 vs no_grad
- PyTorch 模型评估退出
- pyker 模型. eval 蝙蝠数
- PyTorch 模型评估要求 _grad
目录
- PyTorch 模型评估
- PyTorch 模型评估列车
- PyTorch 模型评估
- PyTorch 模型评估与培训
- PyTorch 模型评估 vs no_grad
- PyTorch 模型评估退出
- py torch model . eval batch norm
- PyTorch 模型评估要求 _grad
PyTorch 模型评估
在本节中，我们将了解如何在 python 中评估 PyTorch 模型。
eval()是一种用于模型特定部分的开关，在训练和评估期间表现不同。- 它将模型设置为评估模式，规范化层使用运行统计数据。
代码:
在下面的代码中，我们将导入一些库，从中我们可以评估模型。
- nn。Conv2d() 用于创建卷积核。
- nn。MaxPool2d() 用于应用于由几个输入平面组成的输入信号。
- nn。线性()用于创建前馈网络。
model = TheModelClass()用于初始化模型。- 优化者=优化。SGD(model.parameters()，lr=0.001，momentum=0.8) 用于初始化优化器。
- print("模型状态 _ 字典:")用于打印模型状态 _ 字典。
- print(" Optimizer state_dict:")用于打印优化器 state _ dict。
- torch.save(model.state_dict()，' model_weights.pth') 用于保存模型。
- model . load _ state _ dict(torch . load(' model _ weights . PTH ')用于加载模型。
model.eval()用于评估模型。
import torch
from torch import nn
import torch.optim as optimize
import torch.nn.functional as f
**# Define model**
class TheModelClass(nn.Module):
def __init__(self):
super(TheModelClass, self).__init__()
self.conv1 = nn.Conv2d(5, 8, 7)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(8, 18, 7)
self.fc1 = nn.Linear(18 * 7 * 7, 140)
self.fc2 = nn.Linear(140, 86)
self.fc3 = nn.Linear(86, 12)
def forward(self, X):
X = self.pool(f.relu(self.conv1(X)))
X = self.pool(f.relu(self.conv2(X)))
X = x.view(-1, 16 * 5 * 5)
X = f.relu(self.fc1(X))
X = f.relu(self.fc2(X))
X = self.fc3(X)
return X
model = TheModelClass()
optimizers = optimize.SGD(model.parameters(), lr=0.001, momentum=0.8)
print("Model state_dict:")
for param_tensor in model.state_dict():
print(param_tensor, "\t", model.state_dict()[param_tensor].size())
print("Optimizer state_dict:")
torch.save(model.state_dict(), 'model_weights.pth')
model.load_state_dict(torch.load('model_weights.pth'))
model.eval()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到模型数据在评估后打印在屏幕上。
PyTorch model eval
阅读: PyTorch 保存模型
PyTorch 模型评估列车
在本节中，我们将学习 python 中的 PyTorch 模型评估训练。
- PyTorch 模型评估训练被定义为评估训练数据的过程。eval()函数用于评估训练模型。
eval()是一种用于模型特定部分的开关，在训练和评估期间表现不同。
代码:
在下面的代码中，我们将导入一些模块，从这些模块中我们可以评估训练好的模型。
netout = model()用于初始化模型。print(netout)用于打印模型。- 优化器=优化。SGD(netout.parameters()，lr=0.001，momentum=0.9) 用于初始化优化器。
torch.save()用于保存模型。- model . load _ state _ dict(check point[' model _ state _ dict '])用于加载模型。
- optimizer.load_state_dict(检查点['optimizer_state_dict']) 用于加载优化器。
model.eval()用于评估模型。
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as fun
class net(nn.Module):
def __init__(self):
super(net, self).__init__()
self.conv = nn.Conv2d(5, 8, 7)
self.pool = nn.MaxPool2d(2, 2)
self.conv1 = nn.Conv2d(8, 18, 7)
self.fc = nn.Linear(18 * 5 * 5, 140)
self.fc1 = nn.Linear(140, 86)
self.fc2 = nn.Linear(86, 12)
def forward(self, y):
y = self.pool(fun.relu(self.conv1(Y)))
y = self.pool(fun.relu(self.conv2(y)))
y = y.view(-1, 16 * 5 * 5)
y = fun.relu(self.fc1(y))
y = fun.relu(self.fc2(y))
y = self.fc3(y)
return y
netout = net()
print(netout)
optimizers = optim.SGD(netout.parameters(), lr=0.001, momentum=0.9)
# Additional information
epoch = 7
path = "model.pt"
loss = 0.6
torch.save({
'epoch': epoch,
'model_state_dict': netout.state_dict(),
'optimizer_state_dict': optimizers.state_dict(),
'loss': loss,
}, path)
models = net()
optimizers = optim.SGD(netout.parameters(), lr=0.001, momentum=0.9)
CheckPoint = torch.load(path)
models.load_state_dict(CheckPoint['model_state_dict'])
optimizers.load_state_dict(CheckPoint['optimizer_state_dict'])
Epoch = CheckPoint['epoch']
Loss = CheckPoint['loss']
models.eval()
models.train()
输出:
在下面的输出中，我们可以看到屏幕上对训练好的模型进行了评估。
PyTorch model eval train
PyTorch 模型评估
在本节中，我们将了解 python 中 PyTorch 模型的评估。
模型评估被定义为可以使用不同的评估矩阵来理解模型的过程。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以评估模型。
torch.nn.Linear()用于创建前馈网络。- X = torch.randn(N，D_in) 用于创建一个随机张量来保存输入和输出。
- loss _ func = torch . nn . ms loss(reduction = ' sum ')用于构造损失函数。
- optimizer = torch . optim . SGD(model . parameters()、lr=1e-4) 用于初始化优化器。
- loss = loss_func(Ypred，Y) 用于打印损失。
optimizer.zero_grad()用于优化零梯度。
import torch
class Net(torch.nn.Module):
def __init__(self, Dinp, hidd, Doutp):
super(Net, self).__init__()
self.linear1 = torch.nn.Linear(Dinp, hidd)
self.linear2 = torch.nn.Linear(hidd, Doutp)
def forward(self, X):
h_relu = self.linear1(X).clamp(min=0)
ypred = self.linear2(h_relu)
return ypred
bsize, Dinp, hidd, Doutp = 66, 1001, 101, 11
X = torch.randn(bsize, Dinp)
Y = torch.randn(bsize, Doutp)
modl = Net(Dinp, hidd, Doutp)
loss_func = torch.nn.MSELoss(reduction='sum')
opt = torch.optim.SGD(modl.parameters(), lr=1e-4)
for t in range(500):
Ypred = modl(X)
losses = loss_func(Ypred, Y)
print(t, losses.item())
opt.zero_grad()
losses.backward()
opt.step()
modl.eval()
输出:
运行上面的代码后，我们得到下面的输出，从中我们可以看到模型评估已经完成。
PyTorch model evaluation
PyTorch 模型评估与培训
在本节中，我们将学习 python 中的 PyTorch eval vs train 模型。
train()集合告诉我们的模型，它当前处于训练阶段，它们保留了一些层，如 dropout 和 batch normalization，它们的行为不同，但取决于当前状态。- 调用 eval()时，
eval()集合的行为与 train 集合完全不同，然后我们的模型停用所有层。
代码:
在下面的代码中，我们将导入一些库，从中我们可以看到 eval 和 train 集之间的区别。
- 辍学= nn。Dropout() 用于去除神经网络中的单元。
- X = torch.ones(2，12) 用于初始化张量。
dropout.train()用作训练模式。dropout.eval()用作评估模式。
import torch
import torch.nn as nn
dropout = nn.Dropout()
X = torch.ones(2, 12)
**# Train mode**
dropout.train()
print(dropout(X))
**# Eval mode**
dropout.eval()
print(dropout(X))
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到训练值和 eval 值打印在屏幕上。
PyTorch model eval vs train
阅读: PyTorch nn 线性+例题
PyTorch 模型评估 vs no_grad
在本节中，我们将学习 python 中的 PyTorch 模型 eval vs no_grad 。
eval() 集合告诉所有层您处于 eval 模式。dropout 和 batch norm 图层在 eval 模式下工作，而不是在 train 模式下。
语法:
以下是 eval 的语法:
model.eval()
no_grad() 会影响自动签名的引擎并将其停用，还会减少内存并加快计算速度。
语法:
语法是 no_grad:
torch.no_grad()
另外，请阅读: PyTorch 负载模型+示例
PyTorch 模型评估退出
在这一节中，我们将学习 python 中的 PyTorch 模型 eval dropout 如何工作。
eval dropout 被定义为一个过程，在该过程中，dropout 被去激活并且刚刚通过其输入。
代码:
在下面的代码中，我们将导入 torch 模块，并从中实现 eval dropout 模型。
- nn。Dropout() 用于定义神经元被去激活的概率。
dropout.eval()用于评估模型。print(dropout(X))用于在屏幕上打印数值。
import torch
import torch.nn as nn
dropout = nn.Dropout()
dropout.eval()
print(dropout(X))
输出:
在下面的输出中，我们可以看到 PyTorch 模型 eval dropout 值打印在屏幕上。
PyTorch model eval dropout
阅读: PyTorch 批量标准化
py torch model . eval batch norm
在本节中，我们将学习 python 中的py torch model . eval batch norm。
在继续之前，我们应该了解一些关于 batchnorm 的知识。
批处理被定义为用于训练深度神经网络的过程，该深度神经网络对所有小批量的层的输入进行标准化。
代码:
在下面的代码中，我们将导入一些库，从中我们可以评估 batchnorm。
wid = 64用作宽度。heig = 64用作高度。- batch_one = torch.ones([4，1，64，64]，dtype=torch.float，device = torch . device(" cuda "))用于计算批次。
- output_one = torch.tensor([.5，. 5])。to(torch.device("cuda")) 用于获取批量的输出。
- 优化者= optim。SGD(nets.parameters()，0.0001) 用于初始化优化器。
optimizer . zero _ grad()用于将参数梯度归零。- loss = criteria(netout，outp) 用于计算损失。
- print("t1 loss1:"，train_model(networks，batch_one，output_one)) 用于打印列车模型。
- print("v1 loss1:"，batch_evaluate(networks，batch_one，output_one，True)) 用于打印评估批次。
import torch
import torch.nn as nn
import torch.optim as optim
class net(nn.Module):
def __init__(self, image_size_total):
super(net, self).__init__()
self.conv = nn.Conv2d(1, 64, 3, padding=1)
self.relu = nn.ReLU(inplace=True)
self.bn = nn.BatchNorm2d(64)
self.max_pool = nn.MaxPool2d(2)
self.fc = nn.Linear((image_size_total//4) * 64, 2)
def forward(self, X):
X = self.conv(X)
X = self.relu(X)
X = self.bn(X)
X = self.max_pool(X)
X = X.view(-1, self.numfeatures(X))
X = self.fc(X)
return X
def numfeatures(self, X):
Size = X.size()[1:] # all dimensions except the batch dimension
numfeatures = 1
for i in Size:
numfeatures *= i
return numfeatures
wid = 64
heig = 64
networks = net(wid* heig)
batch_one = torch.ones([4, 1, 64, 64], dtype=torch.float, device=torch.device("cuda"))
output_one = torch.tensor([.5, .5]).to(torch.device("cuda"))
batch_two = torch.randn([4, 1, 64, 64], dtype=torch.float, device=torch.device("cuda"))
output_two = torch.tensor([.01, 1.0]).to(torch.device("cuda"))
def train_model(nets, batch, outp):
nets.train()
optimizers = optim.SGD(nets.parameters(), 0.0001)
criterions = nn.MSELoss()
optimizers.zero_grad()
netout = nets(batch)
loss = criterions(netout, outp)
loss.backward()
optimizers.step()
return float(loss)
def batch_evaluate(nets, batch, outp, should_eval):
if should_eval:
nets.eval()
else:
nets.train()
criterion = nn.MSELoss()
netout = nets(batch)
loss = criterion(netout, outp)
return float(loss)
networks.to(torch.device("cuda"))
for i in range(60):
print("t1 loss1:", train_model(networks, batch_one, output_one))
print("t1 loss2:", train_model(networks, batch_two, output_one))
print("v1 loss1:", batch_evaluate(networks, batch_one, output_one, True))
print("v1 loss2:", batch_evaluate(networks, batch_two, output_one, True))
print("train v1 loss1:", batch_evaluate(networks, batch_one, output_one, False))
print("train v2 loss2:", batch_evaluate(networks, batch_two, output_one, False))
注: 运行代码前在 Google colab 中更改运行时间 None 到 GPU 。更改后，我们的代码运行完美。
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 model.eval() 使用 batchnorm 给出了不正确的损失。
PyTorch model.eval batchnorm
阅读: PyTorch 数据加载器+示例
PyTorch 模型评估要求 _grad
在本节中，我们将学习 python 中的 PyTorch 模型 eval required_grad 。
在 PyTorch 中， requires_grad 被定义为一个参数。如果的值 requires_grad 为 true ，则需要计算梯度。如果为假，就不需要计算梯度。
代码:
在下面的代码中，我们将导入 torch 模块，如果 requires_grad 为真，我们就可以从中计算梯度。
- 辍学= nn。Dropout() 用于定义神经元被去激活的概率。
- X = torch.ones(6，12，requires_grad = False) 用于给 X 变量赋值。
dropout.eval()用作评估模式。print(dropout(X))用于打印数值。
import torch
import torch.nn as nn
dropout = nn.Dropout()
X = torch.ones(6, 12, requires_grad = False)
y =torch.ones(6, 12,requires_grad = True)
dropout.eval()
print(dropout(X))
print(dropout(y))
输出:
在下面的输出中，我们可以看到 PyTorch 模型 eval requires_grad 值被打印在屏幕上。
PyTorch model eval requires_grad
你可能也喜欢阅读下面的 PyTorch 教程。
因此，在本教程中，我们讨论了 PyTorch 评估模型,我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch 模型评估
- PyTorch 模型评估训练
- PyTorch 模型评估
- PyTorch 模型评估与培训
- PyTorch 模型评估 vs no_grad
- PyTorch 模型评估退出
- pyker 模型. eval 蝙蝠数
- PyTorch 模型评估要求 _grad
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch 模型总结-详细教程
在这个 Python 教程中，我们将学习如何用 Python 创建一个 PyTorch 模型摘要，我们还将介绍与 PyTorch 模型摘要相关的不同示例。此外，我们将涵盖这些主题。
- PyTorch 模型摘要
- PyTorch 模型摘要示例
- PyTorch 模型摘要 lstm
- PyTorch 模型摘要多输入
- PyTorch bert 模型摘要
- PyTorch lightning 模型摘要
- PyTorch model summary Keras
目录
- PyTorch 车型总结
- PyTorch 模型总结示例
- PyTorch 模型摘要 lstm
- PyTorch 模型汇总多个输入
- PyTorch bert 模型总结
- PyTorch lightning 模型摘要
- PyTorch model summary Keras
PyTorch 车型总结
在本节中，我们将学习如何用 python 创建 PyTorch 模型摘要。
模型摘要为我们提供了模型的精细可视化，其目的是提供打印语句无法提供的完整信息。
语法:
summary(model,input_size,batch_size=-1,show_input=False, show_hierarchical=False, max_depth=1,print_summary=False,show_parent_layers=False)
参数:
- 模型我们想要使用并获取摘要的模型。
input_size需要通过网络进行前向传递。batch_size被证明并打印在汇总表中。show_input显示每层的输入输出形状。show_hierarchical，添加一个汇总表返回分层视图。- max_depth 定义了它可以在用户定义的层中显示它们的次数。
print_summary，为真时不需要汇总方法之外的打印功能。- show_parennt_layers 它添加一列来显示父层路径，直到到达当前层。
阅读: PyTorch 模型评估+示例
PyTorch 模型总结示例
在本节中，我们将借助一个例子来了解如何实现 PyTorch 模型摘要。
一个模型的概要，它给出了一个很好的可视化，并且模型概要提供了完整的信息。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以获得模型的摘要。
pretrained model _ vgg = models . vgg 16()用作模型。- summary(pretrainedmodel_vgg，(3，224，224)) 给出模型的精细可视化和完整信息。
import torch
from torchvision import models
from torchsummary import summary
pretrainedmodel_vgg = models.vgg16()
summary(pretrainedmodel_vgg, (3, 224, 224))
输出:
在运行上面的代码之后，我们得到了下面的输出，其中我们可以看到模型的摘要被打印在屏幕上。
PyTorch model summary example
阅读: PyTorch 预训练模型
PyTorch 模型摘要 lstm
在本节中，我们将学习 python 中的 PyTorch 模型摘要 lstm 。
在继续之前，我们应该对 lstm 有一些了解。LSTM 代表长短期记忆，非常适合基于时间序列数据进行预测。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以总结模型摘要。
- 班级模型 _ 总结(nn。模块):用于定义一个类。
- nn。Conv2d(1，10，kernel_size=5) 用于实现 CNN 的 2d 卷积层。
- nn。Linear() 用于创建具有输入和输出的单层前馈网络。
device _ name = torch . device(" cuda " if torch . cuda . is _ available()else " CPU ")作为 cuda 设备使用。- summary(modl，(1，28，28)) 用于打印模型摘要。
import torch
import torch.nn as nn
import torch.nn.functional as fun
from torchsummary import summary
class model_summary(nn.Module):
def __init__(self):
super(model_summary, self).__init__()
self.conv = nn.Conv2d(1, 10, kernel_size=5)
self.conv1 = nn.Conv2d(10, 20, kernel_size=5)
self.conv1_drop = nn.Dropout2d()
self.fc = nn.Linear(320, 50)
self.fc1 = nn.Linear(50, 10)
def forward(self, z):
z = fun.relu(fun.max_pool2d(self.conv(z), 2))
z = fun.relu(fun.max_pool2d(self.conv1_drop(self.conv1(z)), 2))
z = z.view(-1, 320)
z = fun.relu(self.fc(z))
z = fun.dropout(z, training=self.training)
z = self.fc1(z)
return fun.log_softmax(z, dim=1)
device_name = torch.device("cuda" if torch.cuda.is_available() else "cpu")
modl = model_summary().to(device_name)
summary(modl, (1, 28, 28))
输出:
在下面的输出中，我们可以看到 PyTorch 模型 lstm 的摘要显示在屏幕上。
PyTorch model summary lstm
阅读: PyTorch 提前停止+示例
PyTorch 模型汇总多个输入
在本节中，我们将学习 python 中的 PyTorch 模型摘要多输入。
模型摘要提供了精细的可视化，还提供了打印功能所不能提供的信息。这里我们给出多个输入。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以获得模型的摘要。
multi _ input device = torch . device(" cuda " if torch . cuda . is _ available()else " CPU ")作为可用设备。- 模型=多输入()。以(multi_inputdevice) 为模型。
- summary(model，[(1，18，18)，(1，30，30)]用于描述一个模型的概要，我们在参数中给出多个输入。
import torch
import torch.nn as nn
from torchsummary import summary
class Multi_input(nn.Module):
def __init__(self):
super(Multi_input, self).__init__()
self.features = nn.Sequential(
nn.Conv2d(1, 1, kernel_size=3, stride=1, padding=1),
nn.ReLU(),
)
def forward(self, y, z):
a1 = self.features(y)
a2 = self.features(z)
return a1, a2
multi_inputdevice = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = Multi_input().to(multi_inputdevice)
summary(model, [(1, 18, 18), (1, 30, 30)])
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到屏幕上显示了具有多个输入的模型的摘要。
PyTorch model summary multiple inputs
PyTorch bert 模型总结
在本节中，我们将学习 python 中的 PyTorch bert 模型摘要。
Bert 模型被定义为双向编码器表示，该模型是为预训练模型而设计的。
伯特模型可以用一个额外的层来改变，以获得最佳模型。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以获得 bert 模型摘要。
torch.manual_seed(dt)用于生成随机数。- BT = bertokenizer . from _ pre trained(' bert-base-un cased ')用作 Bert 记号化器。
pretrained model _ vgg = models . vgg 16()用作预训练模型。- 打印(bertresult) 用于打印 bert 结果。
- summary(pretrainedmodel_vgg，(3，224，224)) 用于获取 bert 摘要。
import torch
from torchvision import models
from torchsummary import summary
dt = 2020
torch.manual_seed(dt)
torch.backends.cudnn.deterministic = True
from transformers import BertTokenizer
pretrainedmodel_vgg = models.vgg16()
BT = BertTokenizer.from_pretrained('bert-base-uncased')
len(BT)
bertresult = BT.tokenize('Hi!! Welcome To The PythonGuides')
print(bertresult)
summary(pretrainedmodel_vgg, (3, 224, 224))
输出:
在下面的输出中，我们可以看到 PyTorch bert 模型摘要打印在屏幕上。
PyTorch bert model summary
阅读: PyTorch 批量标准化
PyTorch lightning 模型摘要
在本节中，我们将学习 python 中的 PyTorch lightning 模型概要。
PyTorch lightning 是一个轻量级的开源模型。它是机器学习研究人员的 python 封面。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以获得 lightning 模型的摘要。
- nn。线性()用于得到带有输入和输出的前馈网络。
embding = self.encoder(m)用于定义预测或推理动作。- def training_step(self，btch，btch_indx) 用于定义独立于 forward 的训练循环。
- optim = torch . optim . Adam(self . parameters()、lr=1e-3) 用于优化优化器。
- dt = MNIST(os.getcwd()，download=True，transform=transforms。【ToTensor()】用于定义数据集。
- trainee . fit(自动编码器，数据加载器(已训练)，数据加载器(有效))用于 fir 训练器。
import os
import torch
from torch import nn
import torch.nn.functional as func
from torchvision.datasets import MNIST
from torch.utils.data import DataLoader, random_split
from torchvision import transforms
import pytorch_lightning as pylig
class litauto_encoder(pylig.LightningModule):
def __init__(self):
super().__init__()
self.encoder = nn.Sequential(nn.Linear(28 * 28, 128), nn.ReLU(), nn.Linear(128, 3))
self.decoder = nn.Sequential(nn.Linear(3, 128), nn.ReLU(), nn.Linear(128, 28 * 28))
def forward(self, m):
embding = self.encoder(m)
return embding
def training_step(self, btch, btch_indx):
m, n = btch
m = m.view(m.size(0), -1)
o = self.encoder(m)
m_hat = self.decoder(o)
losses = func.mse_loss(m_hat, m)
self.log("train_loss", losses)
return losses
def configure_optimizers(self):
optim = torch.optim.Adam(self.parameters(), lr=1e-3)
return optim
dt = MNIST(os.getcwd(), download=True, transform=transforms.ToTensor())
trained, valid = random_split(dt, [55000, 5000])
autoencoder = litauto_encoder()
traine = pylig.Trainer()
traine.fit(autoencoder, DataLoader(trained), DataLoader(valid))
summary(litauto_encoder,(1,28,28))
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch lightning 模型摘要显示在屏幕上。
PyTorch lightning model summary
阅读: PyTorch 负载模型+示例
PyTorch model summary Keras
在本节中，我们将学习 python 中的 PyTorch 模型概要 Kera。
Keras 有一个有序的 API 来查看模型的可视化，这在调试网络时非常有用。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以获得模型摘要。
- nn。Sequential() 当我们希望某些层按顺序排列时使用。
- nn。Conv2d() 用于改变二维数据结构的卷积。
devce = torch . device(" cuda " if torch . cuda . is _ available()else " CPU ")作为设备使用。- modl = smplcon()。to(devce) 用作模型。
- summary(modl，[(1，18，18)，(1，30，30)]用于解释模型摘要。
import torch
import torch.nn as nn
from torchsummary import summary
class smplcon(nn.Module):
def __init__(self):
super(smplcon, self).__init__()
self.features = nn.Sequential(
nn.Conv2d(1, 1, kernel_size=5, stride=1, padding=1),
nn.ReLU(),
)
def forward(self, a, b):
a1 = self.features(a)
a2 = self.features(b)
return a1, a2
devce = torch.device("cuda" if torch.cuda.is_available() else "cpu")
modl = smplcon().to(devce)
summary(modl, [(1, 18, 18), (1, 30, 30)])
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 模型摘要 Keras 被打印在屏幕上。
PyTorch model summary Keras
另外，再看看一些 PyTorch 教程。
- 交叉熵损失 PyTorch
- PyTorch Conv3d
- Jax Vs PyTorch【主要区别】
- PyTorch MNIST 教程
- PyTorch 全连接层
- py torch RNN–详细指南
- Adam 优化器 PyTorch 及示例
- 数据加载器指针+示例
因此，在本教程中，我们讨论了 PyTorch 模型摘要，并且我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch 模型摘要
- PyTorch 模型摘要示例
- PyTorch 模型摘要 lstm
- PyTorch 模型摘要多输入
- PyTorch bert 模型摘要
- PyTorch lightning 模型摘要
- PyTorch model summary Keras
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
py torch ms loss–详细指南
在这个 Python 教程中，我们将学习 Python 中的py torch ms loss，我们还将涵盖与之相关的不同例子。我们将讨论这些话题。
- PyTorch MSELoss
- PyTorch MSELoss 代码
- PyTorch MSELoss 实现
- PyTorch MSELoss 加权
- PyTorch MSELoss nan
- PyTorch MSELoss 批量大小
- 正则化 PyTorch MSELoss
目录
- py torch ms loss
- py torch ms loss 代码
- py torch ms loss 实现
- PyTorch MSELoss Weighted
- py torch ms loss 忽略指数
- py torch ms loss 批量
- py torch ms loss 正则化
py torch ms loss
在本节中，我们将了解 python 中的py torch ms loss 如何工作。
在继续之前，我们应该对 MSELoss 有所了解。
- Mse 代表均方误差，这是最常用的回归损失函数。
- 损失是真实值和预测值之间的平均监督数据平方差。
- PyTorch MSELoss 是一个测量实际值和预测值之间的平均方差的过程。
代码:
在下面的代码中，我们将导入 torch 库，我们可以测量每个元素之间的均方差。
- nn。ms loss()用于测量均方差。
- torch.randn(5，7，requires_grad=True) 用于生成随机数。
- 损失(输入，目标)用于计算损失。
- print(输出)用于在屏幕上打印输出。
import torch
from torch import nn
loss = nn.MSELoss()
inputs = torch.randn(5, 7, requires_grad=True)
targets = torch.randn(5, 7)
output = loss(inputs, targets)
output.backward()
print(output)
输出:
运行上面的代码后，我们得到下面的输出，可以看到屏幕上显示了均方误差损失。
PyTorch MSELoss
py torch ms loss 代码
在本节中，我们将学习 python 中的py torch ms loss 代码。
PyTorch MSELoss code 定义为测量实际值和预测值之间的平均方差的过程。
代码:
在下面的代码中，我们将导入一个 torch 模块，从中我们可以计算 MSELoss。
- torch.randn(2，4，requires_grad=True) 用于生成随机数。
- nn。ms loss()用于计算均方误差。
- ms loss(输入，目标)用于获得输出值。
- print('input:'，inputs) 用于打印输入值。
- print('target:'，targets) 用于打印目标值。
- print('output:'，outputs) 用于打印输出值。
import torch.nn as nn
inputs = torch.randn(2, 4, requires_grad=True)
targets = torch.randn(2, 4)
mseloss = nn.MSELoss()
outputs = mseloss(inputs, targets)
outputs.backward()
print('input: ', inputs)
print('target: ', targets)
print('output: ', outputs)
输出:
在下面的输出中，我们可以看到均方误差损失值被打印在屏幕上。
PyTorch MSELoss code
py torch ms loss 实现
在这一节中，我们将学习如何在 python 中实现 MSELoss 。
PyTorch MSELoss 实现的目的是计算实际值和预测值之间的平均方差。
代码:
在下面的代码中，我们将导入 torch 模块，并从中实现 MSELoss。
- target = torch.randn(3，5) 用于生成目标变量的随机数。
- nn。ms loss()用于计算均方损失误差。
- ms loss(输入，目标)用于计算输出值。
- print('input_value:'，input) 用于打印输入变量。
- print('target_value:'，target) 用于打印目标变量。
- 打印(' output_value:'，outputval) 用于打印输出值。
import torch
import torch.nn as nn
target = torch.randn(3, 5)
mseloss = nn.MSELoss()
outputval = mseloss(input, target)
outputval.backward()
print('input_value : ', input)
print('target_value : ', target)
print('output_value : ', outputval)
输出:
运行上面的代码后，我们得到了下面的输出，其中我们得到了输入值之间的平均平方差。目标值打印在屏幕上。
PyTorch MSELoss implementation
PyTorch MSELoss Weighted
在本节中，我们将学习 Python 中的 Pytorch MSELoss weighted 。
- PyTorch MSELoss weighted 定义为计算输入变量和目标变量之间的均方差的过程。
- MSELoss 最常用于回归，在线性回归中，每个目标变量都被评估为输入变量的加权和。
代码:
在下面的代码中，我们将导入一些库，从中我们可以计算输入变量和目标变量之间的平方差的平均值。
torch . from _ numpy(input _ vals)用作输入变量。torch . from _ numpy(target _ vals)用作目标变量。print(input_vals)用于打印输入的变量。print(target_vals)用于打印目标变量。- weights = torch.randn(4，5，requires_grad=True) 用于生成随机权重。
- bias = torch . randn(4，requires_grad=True) 用于生成随机偏差。
- 预测=模型(input_vals) 用于进行预测。
import torch
import numpy as num
input_vals = num.array([[75, 69, 45],
[93, 90, 61],
[89, 136, 70],
[104, 45, 39],
[72, 98, 81]], dtype='float32')
target_vals = num.array([[64, 73],
[93, 104],
[111, 125],
[36, 45],
[110, 113]], dtype='float32')
input_vals = torch.from_numpy(input_vals)
target_vals = torch.from_numpy(target_vals)
print(input_vals)
print(target_vals)
**# Weights and biases**
weights = torch.randn(4, 5, requires_grad=True)
biases = torch.randn(4, requires_grad=True)
print(w)
print(b)
def model(x):
return x @ w.t() + b
**# Generate predictions**
predictions = model(input_vals)
print(predictions)
print(target_vals)
**# MSEloss**
def mse(t1, t2):
diff = t1 - t2
return torch.sum(diff * diff) / diff.numel()
loss = mse(predictions, target_vals)
print(loss)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch MSELoss weighted 被打印在屏幕上。
PyTorch MSELoss weighted
py torch ms loss 忽略指数
在这一节中，我们将学习 python 中的 PyTorch MSELoss 忽略索引。
在继续之前，我们应该了解一些关于忽略索引的知识。Ignore index 是一个参数，它指定一个被忽略的目标变量，该变量不会对输入渐变产生影响。
语法:
torch.nn.MSELoss(size_average=None,reduce=None,ignore_index=None,reduce=None,reduction='mean')
参数:
size_average是该批中每个损失元素的平均值。- 减少是损失的平均值，根据 size_average 对每个小批量的观察值求和。
ignore_index是一个参数，它指定一个被忽略的目标变量，并且不贡献给输入梯度。- 减少量是指定减少量被应用到输出。
另外，检查: PyTorch 预训练模型
py torch ms loss 批量
在这一节中，我们将学习如何在 python 中实现 PyTorch MSELoss 批处理大小。
PyTorch MSELoss 批量大小定义为在一次迭代中使用大量训练样本的过程。
代码:
在下面的代码中，我们将导入一些库，从中我们可以维护批处理大小。
torch . from _ numpy(input _ var)用作输入变量。torch . from _ numpy(target _ var)用作目标变量。- train _ dataset = TensorDataset(input _ var，target_var) 用于训练数据集。
- batchsize = 3 用于定义批量大小。
- train _ dl = data loader(train _ dataset，batchsize，shuffle=True) 用于加载数据。
- nn。【T1(3，2)】用于创建前馈网络。
print(model.weight)用于打印模型重量。- 预测=模型(input_var) 用于生成预测。
import torch
import torch.nn as nn
import numpy as num
input_var = num.array([[75, 69, 45], [93, 90, 66], [89, 136, 60],
[104, 45, 39], [71, 98, 72], [75, 69, 45],
[93, 90, 66], [89, 136, 60], [104, 45, 39],
[71, 98, 72], [75, 69, 45], [93, 90, 66],
[89, 136, 60], [104, 45, 39], [71, 98, 72]],
dtype='float32')
target_var = num.array([[58, 72], [83, 103], [121, 135],
[24, 39], [105, 121], [58, 72],
[83, 103], [121, 135], [24, 39],
[105, 121], [58, 72], [83, 103],
[121, 135], [24, 39], [105, 121]],
dtype='float32')
input_var = torch.from_numpy(input_var)
target_var = torch.from_numpy(target_var)
input_var
from torch.utils.data import TensorDataset
**# Define dataset**
train_dataset = TensorDataset(input_var, target_var)
train_dataset[0:3]
from torch.utils.data import DataLoader
**# Define data loader**
batchsize = 3
train_dl = DataLoader(train_dataset, batchsize, shuffle=True)
for x_b, y_b in train_dl:
print(x_b)
print(y_b)
**# Define model**
model = nn.Linear(3, 2)
print(model.weight)
print(model.bias)
**# Parameters**
list(model.parameters())
**# Generate predictions**
predictions = model(input_var)
predictions
import torch.nn.functional as f
**# Define loss function**
loss_func = f.mse_loss
loss = loss_func(model(input_var), target_var)
print(loss)
输出:
在下面的输出中，我们将大型数据集分成批量大小为 3 的较小数据集，PyTorch mse bach 大小值打印在屏幕上。
PyTorch MSELoss batch size
读取 PyTorch 模型评估
py torch ms loss 正则化
在这一节中，我们将学习 python 中带有正则化的 PyTorch MSELoss。
使用正则化的 PyTorch MSELoss 是将所有权重的绝对值之和放入模型中的过程。
代码:
在下面的代码中，我们将导入 torch 库，从中我们可以通过正则化计算 PyTorch MSELoss。
- nn。ms loss()用于计算均方误差损失。
- input_var = torch.randn(10，12，requires_grad=True) 用于生成随机输入变量。
- target_var = torch.randn(10，12)用于生成随机目标变量。
- MSE_loss(input_var，target_var) 用于将权重的绝对值相加。
- print("Output:"，output_var) 用于打印输出变量。
import torch
import torch.nn as nn
MSE_loss = nn.MSELoss()
input_var = torch.randn(10, 12, requires_grad=True)
target_var = torch.randn(10, 12)
output_var = MSE_loss(input_var, target_var)
output_var.backward()
print("Output: ", output_var)
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到 PyTorch MSELoss 正则化变量被打印在屏幕上。
PyTorch MSELoss with regularization
您可能会喜欢以下 PyTorch 教程:
因此，在本教程中，我们讨论了py torch ms loss，并且我们还讨论了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch MSELoss
- PyTorch MSELoss 代码
- PyTorch MSELoss 实现
- PyTorch MSELoss 加权
- PyTorch MSELoss nan
- PyTorch MSELoss 批量大小
- 正则化 PyTorch MSELoss
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
py torch nn conv 2d[附 12 例]
在本 Python 教程中，我们将学习 Python 中的 PyTorch nn Conv2d 。conv2d 定义为对系统提供的 2d 矩阵执行的卷积运算。
此外，我们还将介绍与 PyTorch nn Conv2d 相关的不同示例。我们将讨论这些话题。
- PyTorch nn conv2d
- PyTorch nn conv2d 示例
- PyTorch nn 泛函 conv2d
- PyTorch nn conv2d 填充相同
- PyTorch nn conv2d 组
- PyTorch nn conv2d 扩展
- CNN 中的 PyTorch nn conv2d
- PyTorch nn conv2d 偏置
- PyTorch nn conv2d 换位器
- Pytorch nn conv2d 参数
- PyTorch nn conv2d 权值
- PyTorch nn conv2d 输入通道和输出通道
目录
- PyTorch nn conv2d
- PyTorch nn conv2d 示例
- PyTorch nn 泛函 conv2d
- PyTorch nn conv2d 填充相同
- PyTorch nn conv2d 组
- PyTorch nn conv2d 稀释
- PyTorch nn conv2d in CNN
- PyTorch nn conv2d 偏置
- PyTorch nn conv2d 应答
- Pytorch nn conv2d 参数
- PyTorch nn conv2d weight
- PyTorch nn conv2d 输入通道和输出通道
PyTorch nn conv2d
在本节中，我们将学习 python 中的 PyTorch nn conv2d 。
PyTorch nn conv2d 定义为应用于用户指定输入的二维卷积，输入的特定形状以通道、长度和宽度的形式给出，输出以卷积方式给出。
语法:
PyTorch nn conv2d 的语法是:
torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', device=None, dtype=None)
参数:
以下是 PyTorch nn conv2d 的参数:
in_channels用作输入图像中的几个通道。- out_channels 用作卷积产生的通道数。
- kernel_size 用于定义卷积核的大小。
- 跨距用于控制互相关、单个数字或元组的跨距。跨距的默认值为 1。
- 填充用于控制应用于输入的填充量。它可以是字符串，也可以是给定隐式填充量的元组。填充的默认值为 0。
- 膨胀用于控制内核元素之间的间距，膨胀的默认值为 1。
- 组用于控制输入和输出之间的连接。组的默认值为 1。
- 偏差:偏差的默认值为真。如果这是真的，它会给输出增加一个可学习的偏差。如果为假，则不会给输出增加任何可学习的偏差。
所以。由此我们了解了 PyTorch nn conv2d。
阅读: PyTorch 超参数调谐
PyTorch nn conv2d 示例
在本节中，我们将借助 python 中的一个示例来学习如何实现 PyTorch nn conv2d 。
PyTorch nn conv2d 对由多个输入平面组成的输入信号应用 2d 卷积。
这是一个简单的算术运算，我们在二维数据上滑动一个权重矩阵或核心，并执行数据的元素乘法。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch，import torch.nn as nn。
- n = nn。Conv2d(18，35，5，stride=2) 用于平方核和等跨距。
- input = torch.randn(22，18，52，102) 用于通过使用 torch.random()函数来描述变量。
output = n(input)用于声明输出变量。print(output)用于通过print()功能打印输出。
# Importing Libraries
import torch
import torch. nn as nn
# With square kernels and equal stride
n = nn.Conv2d(18, 35, 5, stride=2)
# Describe the variable
input = torch.randn(22, 18, 52, 102)
# Declare the output variable
output = n(input)
# Print output
print(output)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到屏幕上打印了具有方形内核和方形步幅值的 PyTorch nn conv2d。
PyTorch nn conv2d example
PyTorch nn conv2d 就是这样实现的。
PyTorch nn 泛函 conv2d
在本节中，我们将学习 python 中的 PyTorch nn 函数 conv2d 。
PyTorch nn 泛函 conv2d 对从多个输入平面收集的输入图像应用 2d 卷积。
语法:
PyTorch nn 泛函 conv2d 的语法:
torch.nn.functional.conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1)
参数:
以下是函数 conv2d 的参数
- 输入:输入定义为形状的输入张量(minibatch，in_channels)。
- 权重:权重被定义为形状的过滤器(out_channels)
- 偏差:偏差定义为形状的可选偏差张量(out_channels)。偏差的默认值是无。
- 步距:卷积核的步距。stride 的默认值为 1。
- 填充:用于控制应用于输入的填充量。它可以是字符串，也可以是给定隐式填充量的元组。填充的默认值为 0。
- 膨胀:用于控制内核元素之间的间距，膨胀的默认值为 1。
- 组用于控制输入和输出之间的连接。组的默认值为 1。
至此，我们理解了 PyTorch nn 泛函 conv2d。
阅读: PyTorch 激活功能
PyTorch nn conv2d 填充相同
在本节中，我们将学习 python 中填充相同的的 PyTorch nn conv2d。
PyTorch nn conv2d padding same 定义为一个参数，用于控制应用于输入的填充量。
它可以是给定数量的隐式填充的字符串或元组，填充的默认值为 0。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch，import torch.nn as nn。
- a = nn。Conv2d(20，37，7，stride=2) 用于平方核和等跨距。
- a = nn。Conv2d(20，37，(7，9)，stride=(2，1)，padding=(4，2)) 与非方核和不等步幅以及与 padding 一起使用。
- input = torch.randn(24，20，54，104): 这里我们用 torch.randn()函数来描述输入变量。
- 打印(输出)用于使用 print()函数打印输出。
# Importing Libraries
import torch
import torch. nn as nn
# Declaring a variable by using square kernels and equal stride
a = nn.Conv2d(20, 37, 7, stride=2)
# Declaring a variable by using Non-square kernels and unequal stride and padding
a = nn.Conv2d(20, 37, (7, 9), stride=(2, 1), padding=(4, 2))
# Describe the variable
input = torch.randn(24, 20 , 54, 104)
output = a(input)
# Print output
print(output)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch nn conv2d 填充值打印在屏幕上。
PyTorch nn conv2d padding same
这样，我们理解了 python 中 PyTorch conv2d 填充的相同之处。
阅读: PyTorch 全连接层
PyTorch nn conv2d 组
在本节中，我们将了解 python 的 PyTorch nn conv2d 组。
PyTorch nn conv2d 组被定义为用于控制输入和输出之间连接的参数，该组的默认值为 1。
代码:
在下面的代码中，首先我们将导入所有必要的库，如 import torch 和 import torch.nn as nn。
- n = nn。Conv2d(22，37，7，stride=2) 用于平方核和等跨距。
- input = torch.randn(26，22，48，48) 用于通过使用 torch.random()函数来描述变量。
output = n(input)用于声明输出变量。print(output)用于通过print()功能打印输出。
# Importing libraries
import torch
import torch. nn as nn
# With square kernels and equal stride
n = nn.Conv2d(22, 37, 7, stride=2)
# Describe the input variable
input = torch.randn(26, 22, 48, 48)
output = n(input)
# Print the output
print(output)
输出:
在下面的输出中，您可以看到 PyTorch nn conv2d 组值打印在屏幕上。
PyTorch nn conv2d group
阅读: PyTorch 双星交叉熵
PyTorch nn conv2d 稀释
在本节中，我们将了解 python 的 PyTorch nn conv2d 膨胀。
PyTorch nn conv2d 膨胀被定义为用于控制内核元素之间的间距的参数，并且膨胀的默认值是 1。
代码:
在下面的代码中，我们会导入一些必要的库比如 import torch，import torch.nn as nn。
- n = nn。Conv2d(19，36，6，stride=2) 用于平方核和等跨距。
- m = nn。Conv2d(19，36，(6，8)，stride=(2，1)，padding=(7，5)) 用作非方核和不等步距和带 padding。
- m = nn。Conv2d(19，36，(6，8)，stride=(2，1)，padding=(7，5)，exploation =(6，4)) 用作非方核和不等步幅并带有 padding 和 exploation。
- input = torch.randn(23，19，53，103): 这里使用 torch.randn()方法声明输入变量。
- 打印(输出)用于使用 output()函数打印输出。
# Importing Libraries
import torch
import torch.nn as nn
# Declaring a variable by using square kernels and equal stride
n = nn.Conv2d(19, 36, 6, stride=2)
# Declaring a variable by using non-square kernels and unequal stride and padding
m = nn.Conv2d(19, 36, (6, 8), stride=(2, 1), padding=(7, 5))
# Declaring a variable by using non-square kernels, unequal stride, padding and dilation
m = nn.Conv2d(19, 36, (6, 8), stride=(2, 1), padding=(7, 5), dilation=(6, 4))
# Declaring the variable
input = torch.randn(23, 19, 53, 103)
output = m(input)
# Print the output
print(output)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到屏幕上打印了 PyTorch nn conv2d 膨胀值。
PyTorch nn conv2d dilation
这样，我们理解了 PyTorch nn con2d 膨胀。
阅读: PyTorch 数据加载器+示例
PyTorch nn conv2d in CNN
在本节中，我们将学习 python 中的 PyTorch nn conv2d CNN 。
在继续之前，我们应该有一些关于卷积神经网络(CNN)的知识。
卷积神经网络是一种用于图像识别的人工神经网络。
这里我们使用 conv2d 来处理一个卷积神经网络。这是一种简单的数学运算，其中我们在 2d 数据上滑动权重矩阵或核心，并与数据执行逐元素乘法。
代码:
在下面的代码中，我们将导入一些库，如导入 torch，从 torch . autograded 导入变量，导入 torchvision.datasets，导入 torch.nn.init。
batch_size = 34用作超参数。- traindata = dtsets。MNIST(root='MNIST 数据/'，train =真，transform =变换。ToTensor()，download=True) 作为训练 mnist 数据集。
- data loader = torch . utils . data . data loader(dataset = train data，batch_size=batch_size，shuffle=True) 用作数据集加载器。
- 类 CNN(torch.nn.Module): 这里我们借助 init()和 forward()方法创建一个模型类。
CNNmodel = CNN()用于创建模型的实例。
import torch
from torch.autograd import Variable
import torchvision.datasets as dtsets
import torchvision.transforms as transforms
import torch.nn.init
# hyperparameters
batch_size = 34
keepprobab = 1
# MNIST dataset
traindata = dtsets.MNIST(root='MNIST_data/',
train=True,
transform=transforms.ToTensor(),
download=True)
testdata = dtsets.MNIST(root='MNIST_data/',
train=False,
transform=transforms.ToTensor(),
download=True)
# dataset loader
dataloader = torch.utils.data.DataLoader(dataset=traindata,
batch_size=batch_size,
shuffle=True)
# Display informations about the dataset
print('Train dataset:\t',traindata)
print('\nTest dataset:\t',testdata)
# Implementation of CNN/Convnet Model
class CNN(torch.nn.Module):
def __init__(self):
super(CNN, self).__init__()
self.layer1 = torch.nn.Sequential(
torch.nn.Conv2d(1, 34, kernel_size=3, stride=1, padding=1),
torch.nn.ReLU(),
torch.nn.MaxPool2d(kernel_size=2, stride=2),
torch.nn.Dropout(p=1 - keepprobab))
self.layer2 = torch.nn.Sequential(
torch.nn.Conv2d(34, 66, kernel_size=3, stride=1, padding=1),
torch.nn.ReLU(),
torch.nn.MaxPool2d(kernel_size=2, stride=2),
torch.nn.Dropout(p=1 - keepprobab))
self.layer3 = torch.nn.Sequential(
torch.nn.Conv2d(66, 130, kernel_size=3, stride=1, padding=1),
torch.nn.ReLU(),
torch.nn.MaxPool2d(kernel_size=2, stride=2, padding=1),
torch.nn.Dropout(p=1 - keepprobab))
# L4 FC 4x4x130 inputs -> 627 outputs
self.fc1 = torch.nn.Linear(4 * 4 * 130, 627, bias=True)
torch.nn.init.xavier_uniform(self.fc1.weight)
self.layer4 = torch.nn.Sequential(
self.fc1,
torch.nn.ReLU(),
torch.nn.Dropout(p=1 - keepprobab))
# L5 Final FC 627 inputs -> 12 outputs
self.fc2 = torch.nn.Linear(627, 12, bias=True)
torch.nn.init.xavier_uniform_(self.fc2.weight) # initialize parameters
def forward(self, y):
output = self.layer1(y)
output = self.layer2(output)
output = self.layer3(output)
output = output.view(output.size(0), -1) # Flatten them for FC
output = self.fc1(output)
output = self.fc2(output)
return output
#instantiate CNN model
CNNmodel = CNN()
CNNmodel
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 CNN 值中的 PyTorch nn conv2d 被打印在屏幕上。
PyTorch nn conv2d in CNN
这就是我们如何在 CNN 中使用 PyTorch nn conv2d。
阅读: PyTorch 预训练模型
PyTorch nn conv2d 偏置
在本节中，我们将了解 python 的 PyTorch nn conv2d bias。
PyTorch nn conv2d 偏差定义为形状的可选偏差张量(out_channels)。偏差的默认值是无。
代码:
在下面的代码中，首先我们将导入库，如 import torch。
- input = torch.ones(2，2，7，7): 这里我们用 torch.ones()函数来描述输入变量。
- print("Input = "，input) 用于通过 print()函数打印输入的内容。
- m = torch . nn . Conv2d(in _ channels = 1，out_channels = 1，kernel_size = 3): 这里我们使用的是 conv 2d 模块。
- print("Parameters = "，list(m.parameters())) 用于打印参数列表。
- print("bias = "，m.bias) 用于打印偏差。
# Import library
import torch
# Describe the input variable
input = torch.ones(2,2,7,7)
print("Input = ",input)
# Using conv2d module
m = torch.nn.Conv2d(in_channels = 1, out_channels = 1, kernel_size = 3)
# Print the list of the parametrs
print("Net = ",m)
print("Parameters = ",list(m.parameters()))
# Print the bias
print("bias = ",m.bias)
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到 PyTorch nn conv2d 偏置值打印在屏幕上。
PyTorch nn conv2d bias
至此，我们了解了 PyTorch n n conv2d 偏置。
PyTorch nn conv2d 应答
在本节中，我们将学习 python 中的 PyTorch nn conv2d 转置。
PyTorch convtranspose2d 对从一些输入平面收集的输入图像应用 2d 转置卷积运算符。
语法:
PyTorch nn conv2d 转置的语法
torch.nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True, dilation=1, padding_mode='zeros', device=None, dtype=None)
参数:
以下是参数
in_channels用作输入图像中的几个通道。- out_channels 用作卷积产生的几个通道。
kernel_size用作卷积核的大小。- 步距用于控制来自互相关的步距。
- 填充:控制隐式补零的数量。
- output_padding: 控制添加到输出形状一侧的附加尺寸。
- 膨胀:控制内核点之间的间距。
- 组:控制输入和输出之间的连接。
举例:
在下面的代码中，首先我们将导入所有必要的库，如 import torch，import torch.nn as nn。
- a = nn。ConvTranspose2d(18，35，5，stride=2) 作为平方核，等步距。
- a = nn。ConvTranspose2d(18，35，(3，5)，stride=(2，1)，padding=(4，2)) 用作非方核和带 padding 的不等步幅。
- inp = torch.randn(1，18，14，14) 用作精确的输出大小，也可以指定为参数。
- 火炬。尺寸([1，18，8，8]) 用于在屏幕上打印尺寸。
#Importing libraries
import torch
import torch.nn as nn
# With square kernels and equal stride
a = nn.ConvTranspose2d(18, 35, 5, stride=2)
# non-square kernels and unequal stride and with padding
a = nn.ConvTranspose2d(18, 35, (3, 5), stride=(2, 1), padding=(4, 2))
inp = torch.randn(22, 18, 52, 102)
out = a(inp)
# exact output size can be also specified as an argument
inp = torch.randn(1, 18, 14, 14)
dsample = nn.Conv2d(18, 18, 5, stride=2, padding=1)
usample = nn.ConvTranspose2d(18, 18, 5, stride=2, padding=1)
m = dsample(inp)
m.size()
torch.Size([1, 18, 8, 8])
out = usample(m, output_size=inp.size())
out.size()
输出:
在下面的输出中，您可以看到 PyTorch nn conv2d 转置大小打印在屏幕上。
PyTorch nn conv2d transpose
至此，我们了解了 PyTorch nn conv2d 转座。
阅读: PyTorch 批量标准化
Pytorch nn conv2d 参数
在本节中，我们将学习 python 中的 PyTorch nn conv2d 参数。
在继续之前，我们应该了解一些关于参数的知识。参数是作为描述系统或设定其操作条件的集合之一而建立的可测量因素。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch，import torch.nn as nn。
- p = nn。Conv2d(22，39，5，stride=2) 与平方核和等跨距一起使用，平方核和等跨距是 nn.conv2d()方法中使用的参数。
- inp = torch.randn(26，22，56，106) 通过使用 torch.random()函数来描述变量。
out = p(inp)用于声明输出变量。print(out)用于使用print()功能打印输出。
# Importing Libraries
import torch
import torch. nn as nn
# With square kernels and equal stride
p = nn.Conv2d(22, 39, 5, stride=2)
# Describe the variable
inp = torch.randn(26, 22, 56, 106)
# Declare the output variable
out = p(inp)
# Print output
print(out)
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到 PyTorch nn conv2d 参数值打印在屏幕上。
PyTorch nn conv2d parameters
至此，我们了解了 PyTorch nn conv2d 参数。
阅读: PyTorch 负载模型+示例
PyTorch nn conv2d weight
在本节中，我们将学习 python 中的 Pytorch nn conv2d weight 。
PyTorch nn conv2d 权重用于对 2d 数据执行卷积，以及一些附加选项，如填充等。
代码:
在下面的代码中，我们将导入库，如 import torch。
- inp = torch.ones(1，1，6，6) 用于通过使用 torch.ones()函数来描述输入变量。
- print("Input = "，inp) 用于打印输入值。
- print("Parameters = "，list(m.parameters())) 用于打印参数列表。
- print("Weight = "，m.weight) 用于打印重量。
- print("bias = "，m.bias) 用于打印偏差。
# Import library
import torch
# Describe the input variable
inp = torch.ones(1,1,6,6)
# Print input
print("Input = ",inp)
m = torch.nn.Conv2d(in_channels = 1, out_channels = 1, kernel_size = 3)
# Print the parameter list
print("net = ",m)
print("Parameters = ",list(m.parameters()))
# Print the weight
print("Weight = ",m.weight)
# Print the bias
print("bias = ",m.bias)
out = m(inp)
print("Output = ",out)
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到 PyTorch nn conv2d 重量打印在屏幕上。
PyTorch nn conv2d weigh
至此，我们了解了 PyTorch nn conv2d 的重量。
PyTorch nn conv2d 输入通道和输出通道
在本节中，我们将学习 python 中的 PyTorch nn conv2d 输入通道和输出通道。
PyTorch nn conv2d 输入通道用作输入图像中的几个通道。
PyTorch conv2d 输出通道用作卷积产生的通道数。
代码:
在下面的输出中，我们将导入所有必要的库，如 import torch、import Variable from torch . autograted、import torch.nn as nn 和 import torch.nn.functional。
- 班级模型(nn。Module): 这里我们借助 init()和 forward()函数创建一个模型类。
- model = model()用于创建模型的实例。
- print(model)用于借助
print()功能打印模型。
# Importing Libraries
import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as fun
# Create model class
class model(nn.Module):
def __init__(self):
super(model, self).__init__()
# 1 input image channel, 8 output channels, 7x7 square convolution
self.conv1 = nn.Conv2d(1, 8, 7)
self.conv2 = nn.Conv2d(8, 18, 7)
# an affine operation: y = Wx + b
self.fc1 = nn.Linear(18 * 7 * 7, 140)
self.fc2 = nn.Linear(140, 86)
self.fc3 = nn.Linear(86, 12)
def forward(self, y):
# Max pooling over a (2, 2) window
y = fun.max_pool2d(fun.relu(self.conv1(y)), (2, 2))
# If the size is a square you can only specify a single number
y = fun.max_pool2d(fun.relu(self.conv2(y)), 2)
y = y.view(-1, self.numflat_featurs(y))
y = fun.relu(self.fc1(y))
y = fun.relu(self.fc2(y))
y = self.fc3(y)
return y
def numflat_featurs(self, y):
# all dimensions except the batch dimension
size = y.size()[1:]
numfeaturs = 1
for i in size:
numfeaturs *= i
return numfeaturs
# Instantiate the model
model = model()
# Print the model
print(model)
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到 PyTorch nn conv2d 输入通道和输出通道打印在屏幕上。
PyTorch nn conv2d input channels and output channels
至此，我们了解了 PyTorch nn conv2d 的输入通道和输出通道。
另外，再看看一些 PyTorch 教程。
因此，在本教程中，我们讨论了 Pytorch nn conv2d ，并且我们还介绍了与其实现相关的不同示例。这是我们介绍过的型号列表。
- PyTorch nn conv2d
- PyTorch nn conv2d 示例
- PyTorch nn 泛函 conv2d
- PyTorch nn conv2d 填充相同
- PyTorch nn conv2d 组
- PyTorch nn conv2d 扩展
- CNN 中的 PyTorch nn conv2d
- PyTorch nn conv2d 偏置
- PyTorch nn conv2d 换位器
- Pytorch nn conv2d 参数
- PyTorch nn conv2d 权重
- PyTorch nn conv2d 输入通道和输出通道
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch nn 线性+示例
在本 Python 教程中，我们将学习 Python 中的 PyTorch nn linear ，我们还将涵盖与 PyTorch nn linear 相关的不同示例。我们将讨论这些话题。
- PyTorch 神经网络线性
- PyTorch 神经网络线性初始化
- PyTorch nn 线性示例
- PyTorch 神经网络线性激活
- PyTorch nn .线性源代码
- PyTorch 神经线性乙状结肠
- PyTorch 神经网络线性批处理
- PyTorch 神经网络线性输入特征
- PyTorch nn .线性模块列表
- PyTorch nn .线性 nan 到 num
目录
- PyTorch nn 线性
- PyTorch nn 线性初始化
- PyTorch nn 线性示例
- PyTorch 神经线性激活
- PyTorch nn.linear 源代码
- PyTorch 神经线性乙状结肠
- PyTorch nn.linear 批处理
- PyTorch nn . linear in _ features
- PyTorch nn.linear 模块列表
- PyTorch nn.linear nan to num
PyTorch nn 线性
在本节中，我们将了解 PyTorch nn linear 如何在 Python 中工作。
- 在继续之前，我们应该有一个关于线性方程的知识。
- 线性方程的形式为 Ax=B，其中我们可以将 x 定义为输入，B 定义为输出，A 定义为权重。
- PyTorch nn linear 是一个用于创建具有 n 个输入和 m 个输出的单层前馈网络的模块。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以创建一个具有 n 个输入和 m 个输出的单层前馈网络。
- netof model = torch . nn . linear(2，1)；用于创建具有 2 个输入和 1 个输出的单层。
- print(' Network Structure:torch . nn . linear(2，1) :\n '，netofmodel) 用于在屏幕上打印网络结构。
- print('网络权重:\n '，netofmodel.weight) 用于在屏幕上打印网络的权重。
- print('Bias Of Network :\n '，netofmodel.bias) 用于在屏幕上打印网络的基础。
import torch
netofmodel = torch.nn.Linear(2,1);
print('Network Structure : torch.nn.Linear(2,1) :\n',netofmodel)
print('Weight Of Network :\n',netofmodel.weight)
print('Bias Of Network :\n',netofmodel.bias)
在下面的输出中，我们可以看到网络结构、网络的权重以及网络的基础都打印在屏幕上。
PyTorch nn linear with 2 input with 1 output
在下面的代码中，我们将在 2 个输入和 2 个输出的帮助下创建单层。
- print(' Network Structure:torch . nn . linear(2，2) :\n '，netofmodel) 用于在屏幕上打印网络结构。
- print('网络的权重:\n '，netofmodel.weight) 用于在屏幕上打印网络的权重。
- print('网络的偏差:\n '，netofmodel.bias) 用于在屏幕上打印网络的基础。
import torch
netofmodel = torch.nn.Linear(2,2);
print('Network Structure : torch.nn.Linear(2,2) :\n',netofmodel)
print('Weight Of The Network :\n',netofmodel.weight)
print('Bias Of The Network :\n',netofmodel.bias)
在下面的输出中，我们可以看到网络结构、网络的权重、2 输入 2 输出的网络的偏差都打印在屏幕上。
PyTorch nn linear 2 input with 2 output
在下面的代码中，我们将在 2 个输入和 3 个输出的帮助下创建一个单层。
- print(' Network Structure:torch . nn . linear(2，3) :\n '，netofmodel) 用于在屏幕上打印网络结构。
- print('网络的权重:\n '，netofmodel.weight) 用于在屏幕上打印网络的权重。
- print('网络的偏差:\n '，netofmodel.bias) 用于在屏幕上打印网络的基础。
import torch
netofmodel = torch.nn.Linear(2,3);
print('Network Structure : torch.nn.Linear(2,3) :\n',netofmodel)
print('Weight Of The Network :\n',netofmodel.weight)
print('Bias Of The Network :\n',netofmodel.bias)
运行上面的代码后，我们得到了下面的输出，其中我们可以看到网络结构，网络的权重，具有 2 个输入和 3 个输出的网络的偏差被打印在屏幕上。
PyTorch nn linear 2 input with 3 output
在下面的代码中，我们将在 3 个输入和 2 个输出的帮助下创建一个单层。
- print(' Network Structure:torch . nn . linear(3，2) :\n '，netofmodel) 用于在屏幕上打印网络结构。
- print('网络的权重:\n '，netofmodel.weight) 用于在屏幕上打印网络的权重。
- print('网络的偏差:\n '，netofmodel.bias) 用于在屏幕上打印网络的偏差。
import torch
netofmodel = torch.nn.Linear(3,2);
print('Network Structure : torch.nn.Linear(3,2) :\n',netofmodel)
print('Weight Of The Network :\n',netofmodel.weight)
print('Bias Of The Network :\n',netofmodel.bias)
运行上面的代码后，我们得到下面的输出，其中我们可以看到网络结构，网络的权重，以及网络的偏差在 3 个输入和 2 个输出的帮助下打印在屏幕上。
PyTorch nn linear 3 input with 2 output
阅读:蟒蛇皮里的熊猫
PyTorch nn 线性初始化
在本节中，我们将了解 PyTorch nn 线性初始化是如何在 python 中完成的。
- 众所周知，线性神经网络是一个模块，用于在 n 个输入和 m 个输出的帮助下创建一个单层前馈网络。
- Pytorch nn 线性初始化，其中我们还可以借助输入和输出创建前馈网络。
代码:
在下面的代码中，我们将导入 torch 库，从中我们可以创建一个前馈网络。
- self.linear = nn。Linear(weights.shape[1]，weights.shape[0]) 用于将形状赋予权重。
X = self.linear(X)用于定义线性回归的类别。- weight = torch.randn(12，12) 用于生成随机权重。
- outs = model(torch.randn(1，12)) 用于返回变量 argument 定义的张量。
- outs.mean()。()【向后】用于计算平均值。
- print(name，param.grad) 用于打印梯度名称和参数。
import torch
import torch.nn as nn
class MyModule(nn.Module):
def __init__(self, weights):
super(MyModule, self).__init__()
self.linear = nn.Linear(weights.shape[1], weights.shape[0])
with torch.no_grad():
self.linear.weight.copy_(weights)
def forward(self, X):
X = self.linear(X)
return X
weight = torch.randn(12, 12)
model = MyModule(weight)
optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)
outs = model(torch.randn(1, 12))
outs.mean().backward()
for name, param in model.named_parameters():
print(name, param.grad)
w0 = model.linear.weight.clone()
optimizer.step()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到前馈网络被打印在屏幕上。
Pytorch nn linear initialization
PyTorch nn 线性示例
在本节中，我们将学习如何用 python 实现 PyTorch nn 线性示例。
- 神经网络线性模块用于计算线性方程。线性方程的形式为 Ax = B，其中 x 为输入，B 为输出，A 为权重。
- 神经网络线性模块也被定义为用于创建单层前馈网络。
代码:
在下面的代码中，我们将导入一些库，从中我们可以创建一个前馈网络。
- self.conv1 = nn。Conv2d(3，8，7) 用于创建一个具有 3 个输入和 8 个输出的网络。
- self.fc1 = nn。(18 * 7 * 7，140)用于计算线性方程。
- X = f . max _ pool 2d(f . relu(self . con v1(X))，(4，4)) 用于创建一个窗口上的 maxpooling。
- size = x.size()[3:] 用于除批量维度以外的所有维度。
print(len(params))用于打印参数。
import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as f
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 8, 7)
self.conv2 = nn.Conv2d(3, 18, 7)
**# an affine operation: y = Wx + b**
self.fc1 = nn.Linear(18 * 7 * 7, 140)
self.fc2 = nn.Linear(140, 86)
self.fc3 = nn.Linear(86, 12)
def forward(self, X):
X = f.max_pool2d(f.relu(self.conv1(X)), (4, 4))
X = f.max_pool2d(F.relu(self.conv2(X)), 4)
X = x.view(-3, self.num_flat_features(X))
X = f.relu(self.fc1(X))
X = f.relu(self.fc2(X))
X = self.fc3(X)
return X
def num_flat_features(self, x):
size = x.size()[3:]
num_features = 3
for s in size:
num_features *= s
return num_features
net = Net()
print(net)
params = list(net.parameters())
print(len(params))
print(params[0].size())
输出:
在下面的输出中，我们可以看到前馈网络是在 nn.linear 模块的帮助下创建的。
PyTorch nn linear example
PyTorch 神经线性激活
在本节中，我们将了解 python 中 PyTorch nn.linear 激活的工作方式。
- Pytorch nn .线性激活函数被定义为获取输入和输出属性并准备矩阵的过程。
- nn。ReLU 用作创建网络的激活函数，也适合复杂数据。
代码:
在下面的代码中，我们将导入一些 torch 库，从中我们可以创建一个网络。
torch.relu(X)用作创建网络的激活函数。f.leaky_relu(X)用于当单元不活动时允许小的正梯度。- nn。Linear(input_size，hidden_size) 模块，获取输入和输出属性并准备矩阵。
nn.relu用作创建网络的激活函数。
import torch
import torch.nn as nn
import torch.nn.functional as f
X = torch.tensor([-2.0, 2.0, 3.0, 4.0])
**# sofmax**
output = torch.softmax(X, dim=0)
print(output)
softmax = nn.Softmax(dim=0)
output = softmax(X)
print(output)
**# sigmoid**
output = torch.sigmoid(X)
print(output)
sig = nn.Sigmoid()
output = sig(X)
print(output)
**#tanh**
output = torch.tanh(X)
print(output)
t = nn.Tanh()
output = t(X)
print(output)
**# relu**
output = torch.relu(X)
print(output)
relu = nn.ReLU()
output = relu(X)
print(output)
output = f.leaky_relu(X)
print(output)
lrelu = nn.LeakyReLU()
output = lrelu(X)
print(output)
class NeuralNet(nn.Module):
def __init__(self, input_size, hidden_size):
super(NeuralNet, self).__init__()
self.linear1 = nn.Linear(input_size, hidden_size)
self.relu = nn.ReLU()
self.linear2 = nn.Linear(hidden_size, 2)
self.sigmoid = nn.Sigmoid()
def forward(self, X):
outs = self.linear1(X)
outs = self.relu(outs)
outs = self.linear2(outs)
outs = self.sigmoid(outs)
return outs
**#use activation functions directly in forward pass**
class NeuralNet(nn.Module):
def __init__(self, input_size, hidden_size):
super(NeuralNet, self).__init__()
self.linear1 = nn.Linear(input_size, hidden_size)
self.linear2 = nn.Linear(hidden_size, 2)
def forward(self, X):
outs = torch.relu(self.linear1(X))
outs = torch.sigmoid(self.linear2(outs))
return outs
输出:
在下面的输出中，我们可以看到 PyTorch nn.linear 激活值打印在屏幕上。
Pytorch nn.linear activation
阅读: PyTorch 负载模型
PyTorch nn.linear 源代码
在本节中，我们将了解如何用 python 实现 PyTorch nn.linear 源代码。
- PyTorch nn.linear 源代码定义为计算一个线性方程 Ax=B 的过程。
- nn.linear 模块也用于在输入和输出的帮助下创建前馈网络。
代码:
在下面的代码中，我们将导入一些库，从中我们可以创建一个具有输入和输出的网络。
- torch.nn.Linear(1，1) 用于借助 1 个输入 1 个输出创建网络。
torch . nn . ms loss(size _ average = False)用作多重标准损失函数。- torch . optim . SGD(model . parameters()，lr = 0.01) 用于优化参数。
pred_y = model(X_data)用于计算预测的 y 数据。optimizer . zero _ grad()zero grad 用于执行反向传递和更新权重。- 打印(' epoch {}，loss {} '。(epoch，loss.item())【格式】用于打印数据。
import torch
from torch.autograd import Variable
X_data = Variable(torch.Tensor([[2.0], [3.0], [4.0]]))
y_data = Variable(torch.Tensor([[3.0], [5.0], [7.0]]))
class LinearRegressionModel(torch.nn.Module):
def __init__(self):
super(LinearRegressionModel, self).__init__()
self.linear = torch.nn.Linear(1, 1)
def forward(self, X):
y_pred = self.linear(X)
return y_pred
model = LinearRegressionModel()
criterion = torch.nn.MSELoss(size_average = False)
optimizer = torch.optim.SGD(model.parameters(), lr = 0.01)
for epoch in range(400):
pred_y = model(X_data)
**# Compute and print loss**
loss = criterion(pred_y, y_data)
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('epoch {}, loss {}'.format(epoch, loss.item()))
var = Variable(torch.Tensor([[5.0]]))
pred_y = model(var)
print("predict (After training)", 5, model(var).item())
输出:
当我们运行上面的代码时，我们得到下面的输出，我们可以看到 epoch 和 loss 值打印在屏幕上。
PyTorch nn.linear source code
PyTorch 神经线性乙状结肠
在本节中，我们将了解如何用 python 实现 PyTorch nn.linear sigmoid 。
Pytorch nn.linear sigmoid 是一个非线性函数，神经元的激活函数是 sigmoid 函数，它总是给出 0 到 1 之间的单元输出。
代码:
在下面的代码中，我们将导入一些库，从中我们可以创建一个前馈网络。
- X = torch.randn((4，4，4)) 用于生成随机数。
Y = torch.sigmoid(x)用于始终在 0 和 1 之间给出单元的输出。- Y.min()，Y.max() 用于打印最小值和最大值。
- self . linear = torch . nn . linear(input _ dim，1) 用于创建前馈网络。
torch.manual_seed(1)用于设置生成随机数的种子。
import torch
torch.manual_seed(1)
X = torch.randn((4, 4, 4))
Y = torch.sigmoid(x)
Y.min(), Y.max()
)
class MyModel(torch.nn.Module):
def __init__(self, input_dim):
super().__init__()
self.linear = torch.nn.Linear(input_dim, 1)
self.activation = torch.nn.Sigmoid()
def forward(self, X):
x = self.linear(X)
return self.activation(X)
torch.manual_seed(1)
model = MyModel(5)
X = torch.randn((11, 5))
Y = model(X)
Y.min(), Y.max()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到屏幕上打印了 Pytorch nn.linear sigmoid 值。
Pytorch nn.linear sigmoid
PyTorch nn.linear 批处理
在这一节中，我们将学习 python 中 Pytorch nn.linear batch 如何工作。
PyTorch nn.linear batch 模块定义为创建全连接权重矩阵的过程，其中每个输入用于创建输出值。
代码:
在下面的代码中，我们将导入一些库，从中我们可以创建 nn.linear 批处理。
- nn。Sequential() 用于按顺序运行某一层。
torch.manual_seed(43)用于设置固定随机数种子。mlp = mlp()用于初始化 MLP。- 对于范围(0，6)内的历元:用于运行训练循环。
- print(f ' starting epoch { epoch+1 } ')用于打印 epoch。
current_loss = 0.0用于设置当前损耗值。- 输入，target = data 用于获取输入。
output = mlp(input)用于执行正向传递。
import os
import torch
from torch import nn
from torchvision.datasets import CIFAR10
from torch.utils.data import DataLoader
from torchvision import transforms
class MultilayerPerceptron(nn.Module):
def __init__(self):
super().__init__()
self.layers = nn.Sequential(
nn.Flatten(),
nn.Linear(34 * 34 * 4, 65),
nn.BatchNorm1d(65),
nn.ReLU(),
nn.Linear(65, 33),
nn.BatchNorm1d(33),
nn.ReLU(),
nn.Linear(33, 11)
)
def forward(self, X):
'''Forward pass'''
return self.layers(X)
if __name__ == '__main__':
torch.manual_seed(43)
**# Prepare CIFAR-10 dataset**
dataset = CIFAR10(os.getcwd(), download=True, transform=transforms.ToTensor())
trainloader = torch.utils.data.DataLoader(dataset, batch_size=10, shuffle=True, num_workers=1)
mlp = MLP()
**# Define the loss function and optimizer
** loss_function = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(mlp.parameters(), lr=1e-4)
for epoch in range(0, 6):
print(f'Starting epoch {epoch+1}')
current_loss = 0.0
**# Iterate over the DataLoader for training data**
for i, data in enumerate(trainloader, 0):
input, target = data
**# Zero the gradients**
optimizer.zero_grad()
output = mlp(input)
** # Compute loss**
loss = loss_function(output, target)
** # Perform backward pass**
loss.backward()
**# Perform optimization**
optimizer.step()
** # Print statistics**
current_loss += loss.item()
if i % 500 == 499:
print('Loss after mini-batch %5d: %.3f' %
(i + 1, current_loss / 500))
current_loss = 0.0
print('Training process has been finished.')
输出:
当我们运行上面的代码时，我们将得到下面的输出，其中我们可以看到在屏幕上创建了批处理。
PyTorch nn.linear batch
阅读 PyTorch 逻辑回归
PyTorch nn . linear in _ features
在本节中，我们将了解 PyTorch nn.linear in_features 如何在 python 中工作。
py torch nn . linear in _ features定义为对输入数据应用线性变化的过程。in_feature是用作每个输入样本的大小的参数。
代码:
在下面的代码中，我们将导入一些库，从中我们可以对传入的数据应用一些更改。
torch.tensor()用作保存单一数据类型元素的多维矩阵。- in_features = X.shape[1] 用于对传入数据进行一些更改。
- nn。【线性(in_features，out_features)】用于创建网络。
import torch
import torch.nn as nn
X = torch.tensor([[2.0, -2.0],
[0.0, 2.0],
[0.0, 0.0]])
in_features = X.shape[1]
out_features = 3
n = nn.Linear(in_features, out_features)
n.weight
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到 PyTorch nn.linear in_feature 数据打印在屏幕上。
PyTorch nn.linear in_feature
PyTorch nn.linear 模块列表
在本节中，我们将学习如何在 python 中创建 PyTorch nn.linear 模块列表。
PyTorch nn.linear 模块列表被定义为一个可以像系统 Python 列表一样被索引的列表，列表中包含的模块被正确注册，并且对所有模块方法可见。
代码
在下面的代码中，我们将导入一些库，从中我们可以创建 PyTorch nn.linear 模块列表。
- m1 = nn。线性(ninputs，nhidden_unit) 用于创建具有 n 个输入和 m 个输出的前馈网络。
- nn。【Sigmoid()被定义为神经元的激活函数，它给出的单位输出总是在 0 和 1 之间。
- nn。Softmax(dim=1) 用于通过特定 dim 应用于所有切片的输入。
- nn。ModuleList(m) 像一个系统化的 Python 列表一样被索引，列表中包含的模块被正确注册。
- model = neural network(ninputs = 12，nhidden_unit=32，noutput=4) 用于创建模型。
import torch
from torch import nn
import torch.nn.functional as f
class neuralnetwork(nn.Module):
def __init__(self, ninputs, nhidden_unit, noutput):
super().__init__()
m1 = nn.Linear(ninputs, nhidden_unit)
n1 = nn.Sigmoid()
m2 = nn.Linear(nhidden_unit, noutput)
s = nn.Softmax(dim=1)
m = [m1, n1, m2, s]
self.module_list = nn.ModuleList(m)
def forward(self, X):
for f in self.module_list:
X = f(X)
return X
model = neuralnetwork(ninputs=12, nhidden_unit=32, noutput=4)
model
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到屏幕上创建了一个神经网络模块列表。
PyTorch nn.linear module list
PyTorch nn.linear nan to num
在本节中，我们将了解 PyTorch nn.linear nan 如何在 python 中工作。
- 在我们继续之前，我们应该有一些关于南的知识。众所周知，Nan 不是一个数字。
- Nan 是表示数据中缺失值的方式，也是一个浮点值。这里我们把 NAN 转换成 Num。
语法:
torch.nan_to_num(input,nan=0.0,posinf=None,neginf=None,out=None)
语法中使用的参数:
- 输入:输入作为输入张量。
nan用来表示数据中缺失的值。nan 的默认值为 0。- 如果给定了一个数，那么这个数的值将被一个正的无穷大值所代替。如果给定了 None，则正的无穷大值将被由输入 dtypes 值表示的最大有限值替换。
- nehinf: 如果给定一个数的值被一个负的无穷大的值代替。如果给定了 None，则负值由输入 dtypes 值表示的最小有限值表示。
- out: out 作为输出张量。
举例:
在这个例子中，我们导入 torch 库，从中我们可以将 nan 值转换为 num。
- X = torch.tensor([float('nan ')，-float('inf ')，float('inf ')，3.16]) 用于给出 X 值。
torch.nan_to_num(X)用于将 nan 转换为 num。
import torch
X = torch.tensor([float('nan'), -float('inf'), float('inf'), 3.16])
torch.nan_to_num(X)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 nan 到 num 的值被打印在屏幕上。
PyTorch nn.linear nan to num
因此，在本教程中，我们讨论了 PyTorchh nn linear ，并且我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch 神经网络线性
- PyTorch 神经网络线性初始化
- PyTorch nn 线性示例
- PyTorch 神经网络线性激活
- PyTorch nn .线性源代码
- PyTorch 神经线性乙状结肠
- PyTorch 神经网络线性批处理
- PyTorch 神经网络线性输入特征
- PyTorch nn .线性模块列表
- PyTorch nn .线性 nan 到 num
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch nn Sigmoid 教程，带示例
PyTorch nn sigmoid 被定义为 S 形曲线，它不穿过原点，产生一个介于 0 和 1 之间的输出。详细来说，我们将在 python 中使用 PyTorch 讨论 nn Sigmoid。
此外，我们将涵盖与 PyTorch nn sigmoid 相关的不同示例。我们将讨论这些话题。
- 什么是 PyTorch nn sigmoid
- PyTorch nn sigmoid 示例
- 如何使用 PyTorch nn 泛函 sigmoid
- 什么是 PyTorch nn log sigmoid
- PyTorch 神经网络 sigmoid 激活函数
- PyTorch 神经网络 sigmoid 交叉熵
- 什么是 PyTorch 物流乙状结肠
目录
- 什么是 PyTorch nn sigmoid
- py torch nn s 形例子
- 如何使用 PyTorch nn 泛函 sigmoid
- 什么是 PyTorch nn log sigmoid
- py torch nn s 形激活函数
- PyTorch nn sigmoid 交叉熵
- 什么是 py torch logistics sigmoid
什么是 PyTorch nn sigmoid
在本节中，我们将学习 python 中的什么是 PyTorch nn sigmod 。
PyTorch nn sigmoid 被定义为 S 形曲线，它不穿过原点，并产生介于 0 和 1 之间的输出。sigmoid 应用 elementwise 函数。
语法:
PyTorch nn sigmoid 的语法:
torch.nn.Sigmoid()
在 sigmoid()函数中，我们可以输入任意数量的维度。
sigmoid 以输入的形式返回一个具有相同维度和形状的张量，其值在[0，1]范围内。
这样，我们借助 torch.nn.Sigmoid()函数理解了 PyTorch nn sigmoid。
py torch nn s 形例子
在这一节中，我们将借助 python 中的一个例子来了解如何实现 PyTorch nn sigmoid 。
在 PyTorch sigmoid 中，值在 0 和 1 之间减小，图形缩小为 S 形。如果 S 值变为正值，则输出值预测为 1，如果 S 值变为负值，则输出值预测为 0。
代码:
在下面的代码中，首先我们将导入 torch 库，比如 import torch 和 import torch.nn 作为 nn。
- s = nn。Sigmoid(): 这里我们调用的是 Sigmoid()函数。
input = torch.randn(4)用于通过使用 torch.randn()函数来声明输入变量。- output = s(input): 这里我们声明输出变量。
print(output)用于借助print()功能打印输出。
# Import library
import torch
import torch.nn as nn
# Calling the sigmoid function
s = nn.Sigmoid()
# Declaring the input variable
input = torch.randn(4)
# Decribing the output variable
output = s(input)
# Print the output
print(output)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch nn sigmoid 值打印在屏幕上。
PyTorch nn sigmoid
这是我们借助一个例子来理解 PyTorch nn sigmoid 的方法。
如何使用 PyTorch nn 泛函 sigmoid
在本节中，我们将学习如何在 python 中使用 PyTorch nn 函数 sigmoid 。
PyTorch nn 泛函 sigmoid 被定义为基于元素的函数，其中实数减少到 0 和 1 之间的值。
语法:
PyTorch nn 泛函 sigmoid 的语法。
torch.nn.functional.sigmoid(input)
参数:
以下是 PyTorch nn 泛函 sigmoid 的参数:
- 输入:输入参数被定义为输入张量。
这就是我们使用 torch.nn.functional.sigmoid()来理解 PyTorch 泛函 sigmoid 的方法。
什么是 PyTorch nn log sigmoid
在本节中，我们将学习 python 中的什么是 PyTorch nn log sigmoid 。
PyTorch nn log sigmoid 被定义为值在 0 和 1 之间减小，并且图形被减小到 S 的形状，并且它应用元素式函数。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch 和 import torch.nn as nn。
- ls = nn。LogSigmoid(): 这里我们调用的是 LogSigmoid()函数。
input = torch.randn(4)用于通过使用 torch.randn()函数来描述输入变量。- output = ls(input): 这里我们声明输出变量。
- 打印(输出)用于使用 print()函数打印输出。
# Import library
import torch
import torch.nn as nn
# Calling the LogSigmoid() function
ls = nn.LogSigmoid()
# Describing the input variable
input = torch.randn(4)
# Declaring the output variable
output = ls(input)
# Print the output
print(output)
输出:
运行上述代码后，我们得到以下输出，可以看到 PyTorch nn log sigmoid 值打印在屏幕上。
PyTorch nn log sigmoid
所以，有了这个，我们通过使用 nn 理解了 PyTorch nn log sigmoid。LogSigmoid()函数。
读取 PyTorch 提前停止
py torch nn s 形激活函数
在本节中，我们将学习 python 中的 PyTorch nn sigmoid 激活函数。
在继续之前，我们应该有一个关于激活函数的知识。
激活函数是执行计算以给出输出的函数，该输出充当下一个神经元的输入。
代码:
在下面的代码中，我们将首先导入所有必要的库，如 import torch 和 import torch.nn as nn。
- 输入=火炬。张量([4，-5，6，-8]) 用于创建张量。
- sigmoid_fun = nn。Sigmoid(): 这里我们调用的是 Sigmoid 函数。
output = sigmoid _ fun(input)用于将 sigmoid 应用于张量。- 打印(输出)用于使用 print()函数打印输出。
# Importing Libraries
import torch
import torch.nn as nn
# Create a tensor
input = torch.Tensor([4,-5,6,-8])
# Calling the sigmoid function
sigmoid_fun = nn.Sigmoid()
# Applying sigmoid to the tensor
output = sigmoid_fun(input)
# Print the output
print(output)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch nn sigmoid 激活函数值被打印在屏幕上。
PyTorch nn sigmoid activation function
因此，有了这个，我们理解了 PyTorch nn sigmoid 激活函数。
读取 PyTorch 模型评估
PyTorch nn sigmoid 交叉熵
在本节中，我们将学习 python 中的 PyTorch nn sigmoid 交叉熵。
在继续之前，我们应该了解一些关于交叉熵的知识。
交叉熵创建了一个计算目标概率和输入概率之间的交叉熵的标准。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch 和 import torch.nn as nn。
- sce = nn。Sigmoid(): 这里我们调用的是 Sigmoid 函数。
- 损失= nn。BCELoss(): 这里我们调用的是 BCELoss()函数。
- input = torch.randn(5，requires_grad=True) 用于通过使用 torch.randn()函数来描述输入变量。
- target = torch.empty(5)。random_(4) 用于通过 torch.empty()函数描述目标变量。
打印(输出)用于使用 print()函数打印输出。
# Import library
import torch
import torch.nn as nn
# Calling the Sigmoid function
sce = nn.Sigmoid()
# Calling the BCELoss() function
loss = nn.BCELoss()
# Describing the input variable
input = torch.randn(5, requires_grad=True)
# Declaring the target variable
target = torch.empty(5).random_(4)
output = loss(sce(input), target)
# Print output
print(output)
输出:
在下面的输出中，我们可以看到 Pytorch nn sigmoid 交叉熵值打印在屏幕上。
PyTorch nn sigmoid cross entropy
这就是我们借助 nn.sigmoid()函数理解 Pytorch nn sigmoid 交叉熵的方法。
读取数据加载器指针
什么是 py torch logistics sigmoid
在本节中，我们将学习 python 中的什么是 PyTorch 逻辑 sigmoid 。
PyTorch 逻辑 sigmoid 被定义为不通过原点的非线性函数，因为它是 S 形曲线，并且产生位于 0 和 1 之间的输出。它也被称为逻辑 sigmoid 函数。
代码:
在下面的代码中，我们将导入 torch 库，如 import torch，import torch.nn as nn。
- los = nn。Sigmoid (): 这里我们调用的是 Sigmoid()函数。
inp = torch.randn (5)用于通过使用 torch.randn()函数来声明输入变量。- out= los (inp): 这里我们声明输入变量。
print(out)用于使用 print()函数打印输出。
# Importing libraries
import torch
import torch.nn as nn
# Calling the Sigmoid() function
los = nn.Sigmoid ()
# Declaring the input variable
inp = torch.randn (5)
# Describing the output variable
out= los (inp)
# Print the output
print(out)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 逻辑 sigmoid 值打印在屏幕上。
Pytorch logistic sigmoid
因此，我们用神经网络理解了 PyTorch 逻辑 sigmoid。西格蒙德()函数。
因此，在本教程中，我们讨论了 PyTorch nn Sigmoid ,我们还讨论了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- 什么是 PyTorch nn sigmoid
- PyTorch nn sigmoid 示例
- 如何使用 PyTorch nn 泛函 sigmoid
- 什么是 PyTorch nn log sigmoid
- PyTorch 神经网络 sigmoid 激活函数
- PyTorch 神经网络 sigmoid 交叉熵
- 什么是 PyTorch 物流乙状结肠
您可能会喜欢以下 PyTorch 教程:
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch Numpy 到张量[有 11 个例子]
在本 Python 教程中，我们将学习 PyTorch Numpy to Tensor 。PyTorch Numpy to Tensor 定义为从 Numpy . NDA array 创建张量的过程。此外，我们还将介绍与 PyTorch NumPy to tensor 相关的不同示例。也涵盖了这些主题。
- numpy 的喇叭是张量
- PyTorch 数值到张量浮点 64
- Pytorch numpy to tensor GPU
- numpy 张量是 dtype 张量
- PyTorch numpy.ndarray 到张量
- PyTorch 将 numpy 转换为张量
- numpy 的喇叭是 int 的张量
- Pytorch numpy 到张量 CPU
- PyTorch numpy 到 CUDA 张量
- PyTorch numpy 到张量列表
- PyTorch 数字图像到张量
目录
- 【numpy 指针为张量
- py torch numpy to tensor float 64
- Pytorch numpy 到张量 GPU
- py torch numpy to tensor dtype
- PyTorch numpy.ndarray 到张量
- PyTorch 将 numpy 转换为张量
- 【numpy 指针是 int 的张量
- 【numpy 指针是 CPU 张量
- PyTorch numpy 到 CUDA 张量
- PyTorch numpy to 张量列表
- PyTorch numpy 图像到张量
【numpy 指针为张量
在这一节中，我们将学习 python 中的 PyTorch NumPy to tensor 。
张量是一种特定的数据结构，非常接近于数组和矩阵。在 Pytorch 中，我们使用张量来加密模型的输入和输出。
*torch . from _ numpy()*函数支持将 numpy 数组转换为张量。
代码:
在下面的代码中，首先我们将导入所有必要的库，如 import torch，并将 numpy 作为 np 导入。
- 数据= [[2，4]，[4，8]] 用作数据。
n _ data = torch . tensor(data)用作可以直接从数据中创建的张量。print(n_data)用于通过 print()函数打印 n_data。t _ num = torch . from _ numpy(num _ array)这里张量可以从 numpy 数组中创建。print(t_num)用于通过 print()函数打印 t_num。
# Importing libraries
import torch
import numpy as np
# Tensor can created directly from numdata
num_data = [[2, 4], [4, 8]]
n_data = torch.tensor(num_data)
print(n_data)
# Tensor can be created from numpy array
num_array = np.array(num_data)
t_num = torch.from_numpy(num_array)
print(t_num)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 numpy 数组被转换为张量，结果被打印在屏幕上。
PyTorch numpy to tensor
有了这个，我们明白了如何把 NumPy 转换成张量。
py torch numpy to tensor float 64
在这一节中，我们将学习如何在 python 中将 PyTorch numpy 转换为 tensor float 64 。
在前进之前，我们应该有一些关于浮动的知识。Float 是一种数据类型，包括以十进制格式表示的分数。
PyTorch numpy to tensor float64 用于将 numpy 数组转换为 tensor float64 数组。
代码:
在下面的代码中，首先我们将导入所有必要的库，如 import torch，并将 numpy 作为 np 导入。
- 数据= [[2。，4]，[4，8]，[5，10]] 用作数据。
n_data = torch.tensor(数据)用作张量可以直接从数据中创建。 print(n_data)用于通过 print()函数打印 n_data。
t _ num = torch . from _ numpy(num _ array)这里张量可以从 numpy 数组中创建。
print(t_num)用于通过 print()函数打印 t_num。print(t_num)用于打印张量数组。print(t_num.shape)用于打印张量数组形状。print(t_num.dtype)用于打印张量数组数据类型。
# Importing libraries
# Importing libraries
import torch
import numpy as np
# Tensor can created directly from numpy data
data = [[2., 4], [4, 8], [5,10]]
n_data = torch.tensor(data)
print(n_data)
# Tensor can be created from numpy array
num_array = np.array(data)
t_num = torch.from_numpy(num_array)
# Print output
print(t_num)
print(t_num.shape)
print(t_num.dtype)
输出:
在下面的输出中，您可以看到 PyTorch numpy 数组被转换为张量 float64。
PyTorch numpy to tensor float64
这就是我们如何通过使用 torch.from_numpy()函数将 numpy 数组转换为张量浮点数。
阅读: PyTorch MNIST 教程
Pytorch numpy 到张量 GPU
在这一节中，我们将学习如何在 python 中将 PyTorch numpy 转换为 tensor GPU 。
PyTorch 张量与 numpy ndarrays 相同，只是张量可以在 GPU 上运行。它只是一个 n 维数组，使用任意数值计算。
PyTorch numpy 转张量 GPU 是一个将 numpy 转换为张量 GPU 的过程。张量存储在 GPU 上，共享同一个内存。
代码:
在下面的代码中，首先我们将导入所有必要的库，如 import torch，并将 numpy 作为 np 导入。
x = np.eye(4)用作内置函数，用于返回矩阵。- torch.from_numpy(x)。to("cuda") 用于将 numpy 转换为张量 GPU。
# Importing linraries
import torch
import numpy as np
# Using np.eye() function
x = np.eye(4)
# Converting numpy to tensor GPU
torch.from_numpy(x).to("cuda")
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 numpy 到 tensor GPU 的转换打印在屏幕上。
PyTorch numpy to tensor GPU
因此，通过这个，我们了解了如何将 numpy 转换为张量 GPU。
阅读: PyTorch 全连接层
py torch numpy to tensor dtype
在本节中，我们将学习如何在 python 中将 PyTorch numpy 转换为张量 dtype 。
在继续之前，我们应该了解一些关于 dtype 的知识。
dtype 是一种数据类型，它描述了固定大小的内存块与数组保持联系的字节数。数据类型的类型有整型、浮点型等。
PyTorch numpy to tensor dtype 定义为将 numpy 转换为 tensor dtype 数组的过程。
代码:
在下面的代码中，首先我们将导入所有必要的库，如 import torch，并将 numpy 作为 np 导入。
- array = numpy.array([2.0，-0.4，4.4，-3.1，0.1]) 用作大小为五的 numpy 数组。
print(array)用于通过 print()函数打印数组。tensor = torch . from_numpy(array)用于应用 from _ numpy()函数，并将结果张量存储在“tensor”中。print(tensor)用于通过使用print()函数来打印张量。
# Importing the PyTorch library
import torch
import numpy
# A numpy array of size 5
array = numpy.array([2.0, -0.4, 4.4, -3.1, 0.1])
print(array)
# Applying the from_numpy function and
# storing the resulting tensor in 'tensor'
tensor = torch.from_numpy(array)
print(tensor)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch numpy to tensor dtype 打印在屏幕上。
PyTorch numpy to tensor dtype
这就是我们如何将 numpy 数组转换成张量数据类型，并获得张量数组的数据类型。
阅读: PyTorch 双星交叉熵
PyTorch numpy.ndarray 到张量
在本节中，我们将学习如何在 python 中将 PyTorch numpy.ndarray 转换为张量。
PyTorch 张量与 NumPy ndarrays 相同，只是张量可以在 GPU 上运行。它只是一个 n 维数组，使用任意数值计算。
代码:
在下面的代码中，首先我们将导入所有必要的库，如 import torch，并将 numpy 作为 np 导入。
- b = np.array([[2，4，6]，[3，1，2]，[3，4，5]，[6，7，5]]) 用于创建一个 numpy.ndarray b
- print("b:\n "，b) 用于通过 print()函数打印 b 值。
- print("Type of b :\n "，type(b)) 用于打印 b 的类型。
ten = torch.from_numpy(b)用于将 numpy.ndarray 转换为张量。- print("tensor:\n "，ten) 用于通过 print()函数打印张量。
- 打印("转换后类型:\n "，类型(十))用于打印转换后的类型。
# import the libraries
import torch
import numpy as np
# Create a numpy.ndarray "b"
b = np.array([[2,4,6],[3,1,2],[3,4,5],[6,7,5]])
print("b:\n", b)
print("Type of b :\n", type(b))
# Convert the numpy.ndarray to tensor
ten = torch.from_numpy(b)
print("tensor:\n", ten)
print("Type after conversion:\n", type(ten))
输出:
在下面的输出中，可以看到屏幕上打印出了 PyTorch numpy.ndarray 到张量 的值。
PyTorch numpy.ndarray to tensor
这样，我们就明白了如何将 numpy.ndarray 转换成张量。
阅读: PyTorch 逻辑回归
PyTorch 将 numpy 转换为张量
在这一节中，我们将学习如何用 python 将 PyTorch numpy 转换成张量。
PyTorch 张量类似于 numpy.ndarray，这里我们将借助 torch.from_numpy() 函数将 numpy 数组转换为张量。
代码:
在下面的代码中，首先我们将导入所有必要的库，如 import torch，并将 numpy 作为 np 导入。
- array = np.array([2，4，6，8，10，12]) 通过使用
np.array()函数来描述变量。 tensor _ x = torch . from _ numpy(array)用于将 numpy 数组转换为张量。print(tensor_x)用于打印张量 x 值。print(tensor_y)用于打印张量 y 值。print(tensor_z)用于打印张量 y 值。
# Importing Libraries
import torch
import numpy as np
# Describing an array
array = np.array([2, 4, 6, 8, 10, 12])
# Convert Numpy array to torch.Tensor
tensor_x = torch.from_numpy(array)
tensor_y = torch.Tensor(array)
tensor_z = torch.tensor(array)
# Print outputs
print(tensor_x)
print(tensor_y)
print(tensor_z)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 将 numpy 转换为张量数组打印在屏幕上。
PyTorch transforms numpy to tensor
这就是我们如何将 numpy 数组转换成张量数据类型，并获得张量数组的数据类型。
阅读: PyTorch 提前停止+示例
【numpy 指针是 int 的张量
在本节中，我们将学习如何在 python 中将 PyTorch numpy 转换为 tensor int 。
PyTorch numpy to tensor 是我们借助 torch.from_numpy()函数将 numpy 数组转换为 tensor int 的过程。
代码:
在下面的代码中，首先我们将导入所有必要的库，如 import torch，并将 numpy 作为 np 导入。
- n_data = np.array([[2，4]，[6，8]，[10，12]]) 定义为 numpy 数组。
numdata = torch.tensor(n_data)这里张量可以通过使用 torch . tensor()直接从 n _ data 创建。t _ num = torch.from_numpy(num _ array)用于借助 torch . from _ numpy()函数将 numpy 转换为张量。print(t_num)用于通过 print()函数打印 t_num。print(t_num.shape)用于打印 t_num 的形状。print(t_num.dtype)用于打印 t_num 的数据类型。
# Importing libraries
import torch
import numpy as np
# Tensor can created directly from n_data
n_data = [[2, 4], [6, 8], [10,12]]
numdata = torch.tensor(n_data)
print(numdata)
# Tensor can be created from numpy array
num_array = np.array(n_data)
t_num = torch.from_numpy(num_array)
# Print output
print(t_num)
print(t_num.shape)
print(t_num.dtype)
输出:
在下面的输出中，您可以看到 PyTorch numpy 到 tensor int 的转换打印在屏幕上。
PyTorch numpy to tensor int
有了这个，我们知道了如何将 PyTorch numpy 转换成张量 int。
【numpy 指针是 CPU 张量
在本节中，我们将学习如何在 python 中将 PyTorch numpy 转换为张量 CPU 。
PyTorch numpy 到张量 CPU 是一个将 numpy 转换为张量 CPU 的过程。NumPy 数组存储在 CPU 上，并共享相同的内存。
代码:
在下面的代码中，首先我们将导入所有必要的库，如 import torch，并将 numpy 作为 np 导入。
- numpy_array = np.array([[3，6，9]，[4，8，16]，[5，10，25]]) 用于使用 np.array()函数创建一个 numpy 数组。
print(numpy_array)用于借助 print()函数打印 numpy 数组。tensor _ arr = torch . from _ numpy(numpy _ array)用于借助 torch.from_tensor()函数将 numpy 数组转换为张量 CPU。
# Importing libraries
import torch
import numpy
# Create a numpy array
numpy_array = np.array([[3,6,9],[4,8,16],[5,10,25]])
print(numpy_array)
# Comversion of numpy to tensor CPU
tensor_arr = torch.from_numpy(numpy_array)
tensor_arr
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch numpy 到 tensor CPU 的转换打印在屏幕上。
PyTorch numpy to tensor CPU
这就是我们如何将 PyTorch numpy 数组转换成张量 CPU。
PyTorch numpy 到 CUDA 张量
在本节中，我们将学习如何在 python 中将 PyTorch numpy 转换成 CUDA 张量。
在继续之前，我们应该了解一些关于 CUDA 的知识。
CUDA 代表计算统一设备架构，这是一个应用程序编程接口，允许软件使用特定类型的 GPU。
PyTorch numpy 到 CUDA 张量被定义为将 PyTorch numpy 转换为 CUDA 张量的过程。
代码:
在下面的代码中，首先我们将导入所有必要的库，如 import torch，并将 numpy 作为 np 导入。
- numpy_array = np.array([[3，6，9]，[4，8，16]，[5，10，25]]) 用于创建一个 numpy 数组。
print(numpy_array)用于通过 print()函数打印 numpy 数组。- device = torch . device(" cuda:0 " if torch . CUDA . is _ available()else " CPU ")这里我们声明设备并检查 CUDA 是否可用。
- tensor _ GPU = torch . from _ numpy(numpy _ array)。【T1 到(device)】用于将 numpy 转换为 CUDA 张量。
print(tensor_gpu)用于打印 CUDA 张量。
# Importing libraries
import torch
import numpy
# Create a numpy array
numpy_array = np.array([[3,6,9],[4,8,16],[5,10,25]])
print(numpy_array)
# Declaring the device
# check Cuda is available or not
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# Converting numpy to CUDA tensor
tensor_gpu=torch.from_numpy(numpy_array).to(device)
print(tensor_gpu)
输出:
在下面的输出中，您可以看到 PyTorch numpy 到 CUDA 张量的转换打印在屏幕上。
PyTorch numpy to CUDA tensor
这样，我们就明白了如何将 PyTorch numpy 转换成 CUDA 张量。
Read: Keras Vs PyTorch
PyTorch numpy to 张量列表
在这一节中，我们将学习如何在 python 中将 PyTorch numpy 转换成张量列表。
PyTorch numpy 转张量表定义为借助 tensor.from_numpy()函数将 PyTorch numpy 转换为张量表的过程。
代码:
在下面的代码中，首先我们将导入所有必要的库，如 import torch，并将 numpy 作为 np 导入。
- array = np.array([[3，9，15]，[4，12，20]，[5，15，30])用于创建一个 numpy 数组。
print(array)用于使用 print()函数打印 numpy 数组。list _ of _ tensor = torch.from_numpy(numpy _ array)用于使用 torch . from _ numpy()函数将 numpy 数组转换为张量列表。print(list_of_tensor)用于打印张量列表。
# Importing libraries
import torch
import numpy
# Create a numpy array
array = np.array([[3,9,15],[4,12,20],[5,15,30]])
print(array)
# Comversion of numpy to tensor CPU
list_of_tensor = torch.from_numpy(numpy_array)
print(list_of_tensor)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch numpy 到张量列表的转换打印在屏幕上。
Pytorch numpy to tensor list
这就是我们如何将 PyTorch numpy 转换成张量列表。
阅读: PyTorch 负载模型+示例
PyTorch numpy 图像到张量
在本节中，我们将学习如何在 python 中将 PyTorch numpy 图像转换为张量。
PyTorch numpy 图像到张量定义为使用 tensor.from_numpy()函数将 PyTorch numpy 图像转换为张量的过程。
代码:
在下面的代码中，首先我们将导入所有必要的库，如 import torch，并从 skimage 导入 io。
- img = io . im read(' input . png ')用于读取图像。
- device = torch . device(" cuda:0 " if torch . cuda . is _ available()else " CPU ")用作本次转换中使用的设备。
- img = torch.from_numpy(img)。float() 用于将 PyTorch numpy 图像转换为张量。
print(img.device)用于借助 print()函数打印 image.device。
# Importing libraries
import torch
from skimage import io
# Reading an image
img = io.imread('input.png')
# Using the devide
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)
# Converting numpy image to tensor
img = torch.from_numpy(img).float()
print(img.device)
输出:
在下面的输出中，你可以看到 numpy 图像到张量的转换打印在屏幕上。
PyTorch numpy image to tensor
你可能也喜欢阅读下面的 PyTorch 教程。
因此，在本教程中，我们讨论了 PyTorch numpy to tensor ，并且我们还讨论了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- numpy 的喇叭是张量
- PyTorch 数值到张量浮点 64
- Pytorch numpy to tensor GPU
- numpy 张量是 dtype 张量
- PyTorch numpy.ndarray 到张量
- PyTorch 将 numpy 转换为张量
- numpy 的喇叭是 int 的张量
- PyTorch numpy 到张量 CPU
- PyTorch numpy 到 CUDA 张量
- PyTorch numpy 到张量列表
- PyTorch 数字图像到张量
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何使用 PyTorch Polar
torch.polar() 函数用于利用绝对值和角度构造一个复数。详细来说，我们将在 Python 中使用 PyTorch 来讨论极坐标函数。
此外，我们将讨论与 PyTorch 极坐标函数相关的不同示例。我们将讨论这些话题。
- 什么是 PyTorch polar
- PyTorch polar()示例
- PyTorch polar 用浮点类型创建角度，用数据类型构造复张量
- 如何使用 PyTorch 极坐标
- PyTorch 极坐标用 double 类型创建角度，用 data 类型构造复张量
- PyTorch 极坐标用 double 型创建角度，用 float 型构造复张量
- Pytorch polar 构造了一个 dtype 为 torch.complex64 的复张量，具有张量的绝对长度和角度
- Pytorch polar 构造了一个 dtype 为 torch.complex128 的复张量，具有张量的绝对长度和角度
目录
- py torch polar 是什么？
- PyTorch polar()示例
- PyTorch polar 用浮点类型创建角度，用数据类型构造复张量
- 如何使用 PyTorch 极坐标
- PyTorch polar 用 double 类型创建角度，用 data 类型构造复张量
- PyTorch polar 用 double 类型创建角度，用 float 类型构造复张量
- Pytorch polar 构造了一个 dtype 的复张量为 torch.complex64，具有张量的绝对长度和角度
- Pytorch polar 构造了一个 dtype 的复张量为 torch.complex128，具有张量的绝对长度和角度
py torch polar 是什么？
在这一节中，我们将学习 python 中的 PyTorch polar 。
极坐标是用于构造复数的函数，该复数的元素是笛卡尔坐标的，并且与具有绝对值和角度的极坐标相关。
语法:
torch.polar(abs, angle, out=None)
参数:
- ABS:ABS 是复张量的绝对值。
- 角度:角度是一个参数，是复张量的角度。
- out = None:out 是 polar()函数的输出张量。
这样，我们借助 torch.polar()函数理解了 Pytorch polar。
阅读: PyTorch 栈教程+示例
PyTorch polar()示例
在这一节中，我们将借助 python 中的一个例子来学习如何实现极坐标函数。
这里我们调用的是 polar()函数，我们可以用绝对值和角度构造一个复数。绝对值和角度必须是浮点数和双精度数。
代码:
在下面的代码中，我们将导入所需的库，如 import torch，并将 numpy 作为 np 导入。
- absolute value = torch.tensor([3，4]，dtype=torch.float64) 用于通过使用 torch . tensor()函数来描述变量。
- p = torch.polar(absolutevalue，and): 这里我们调用的是 torch.polar()函数。
print(p)用于通过 print()函数打印输出。
# Import Library
import torch
import numpy as np
# Describing the variables
absolutevalue = torch.tensor([3, 4], dtype=torch.float64)
ang = torch.tensor([np.pi / 2, 7 * np.pi / 6], dtype=torch.float64)
# Calling the Polar() function
p = torch.polar(absolutevalue, ang)
# Print the output
print(p)
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到 PyTorch 极坐标值打印在屏幕上。
PyTorch polar example
这样，我们借助一个例子理解了 PyTorch 极。
PyTorch polar 用浮点类型创建角度，用数据类型构造复张量
在本节中，我们将学习 PyTorch 极坐标创建浮点型角度，并使用 python 中的数据类型构造复张量。
这里我们使用 torch.polar()函数，从这个函数中我们构造了浮点类型的完美长度和角度，还构造了复张量和数据类型。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch 和 import numpy。
- absolute value = torch . tensor([25，47，69，56，34]，dtype=torch.float32) 用于创建浮点类型的绝对长度。
- ang = torch . tensor([numpy . pi/4，numpy.pi / 6，numpy.pi /5，numpy.pi / 7，0]，dtype=torch.float32): 这里我们用 float 类型创建角度。
- print(torch . polar(absolute value，and)) 用于构造复张量。
- print(torch . polar(absolute value，ang)。dtype): 我们在这里构造复张量并显示数据类型。
# Importing libraries
import torch
import numpy
# Creating the absolute lengths with float type
absolutevalue = torch.tensor([25, 47, 69, 56, 34], dtype=torch.float32)
# Creating the angles with float type
ang = torch.tensor([numpy.pi / 4, numpy.pi / 6, numpy.pi /
5, numpy.pi / 7, 0], dtype=torch.float32)
# Construct the complex tensor
print(torch.polar(absolutevalue, ang))
# Construct the complex tensor and display the datatype
print(torch.polar(absolutevalue, ang).dtype)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch polar 创建了一个浮点类型的角度，并构造了一个数据类型为的复张量，值打印在屏幕上。
PyTorch polar create angles with float type and constructs complex tensor with data type
这就是我们如何理解 PyTorch polar 用 float 类型创建角度，用 data 类型构造复杂张量。
如何使用 PyTorch 极坐标
在本节中，我们将学习 python 中的 PyTorch 极坐标。
在前进之前，我们应该有一个关于坐标的知识。
坐标是将一个复合活动的不同要素纳入一个系统关系的坐标。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch 和 import numpy as np。
- absolute value = torch . tensor([2，4]，dtype=torch.float32): 这里我们定义复张量的绝对值。
- ang = torch.tensor([np.pi / 4，np.pi/6]，dtype=torch.float32): 这里我们定义的是复张量的角度。
- print("absolutevalue:"，absolutevalue) 用于打印绝对值。
- print("angle:"，ang) 用于通过 print()函数打印角度。
- p = torch.polar(absolutevalue，ang): 这里我们调用的是 torch.polar()函数。
# Importing Libraries
import torch
import numpy as np
# define the absolute value and angle of the complex tensor
absolutevalue = torch.tensor([2,4], dtype=torch.float32)
ang = torch.tensor([np.pi / 4, np.pi/6], dtype=torch.float32)
# print absolute value and angle
print("absolutevalue:", absolutevalue)
print("angle:", ang)
p = torch.polar(absolutevalue, ang)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 极坐标值被打印在屏幕上。
PyTorch polar coordinates
这就是我们在 python 中理解 PyTorch 极坐标的方法。
阅读: PyTorch 整形张量
PyTorch polar 用 double 类型创建角度，用 data 类型构造复张量
在本节中，我们将了解 PyTorch 极坐标使用 double 类型创建角度，并使用 python 中的数据类型构造复张量。
在这里，我们使用 torch.polar()函数来构造数据类型的复张量，并创建双精度类型的角度。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch 和 import numpy。
- absolute value = torch . tensor([25，47，69，54，36]，dtype=torch.double): 这里我们用 double 类型创建绝对长度。
- ang = torch . tensor([numpy . pi/4，numpy.pi / 6，numpy.pi / 5，numpy.pi / 7，0]，dtype=torch.double): 这里我们用 float 类型创建角度。
- print(torch . polar(absolute value，ang)) 用于构造复张量。
- print(torch . polar(absolute value，ang)。dtype) 用于通过 print()函数打印绝对值和角度。
# Importing libraries
import torch
import numpy
# Creating the absolute lengths with double type
absolutevalue = torch.tensor([25, 47, 69, 54, 36], dtype=torch.double)
# Creating the angles with float type
ang = torch.tensor([numpy.pi / 4, numpy.pi / 6, numpy.pi /
5, numpy.pi / 7, 0], dtype=torch.double)
# Construct the complex tensor
print(torch.polar(absolutevalue, ang))
# Construct the complex tensor and display the datatype
print(torch.polar(absolutevalue, ang).dtype)
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到 py torch polar create with double type 和 constructed complex tensor with data type values 打印在屏幕上。
PyTorch polar create angles with double type and construct complex tensor with data type
这就是我们对 PyTorch 极坐标的理解，用 double 类型创建角度，用 data 类型构造复杂张量。
阅读: Jax Vs PyTorch
PyTorch polar 用 double 类型创建角度，用 float 类型构造复张量
在这一节中，我们将学习双精度类型的 Pytorch 极角，并在 python 中构造浮点类型的复杂张量。
在这里，我们使用 torch.polar()函数来构造数据类型的复张量，并创建浮点类型的角度。
代码:
在下面的代码中，我们将导入 torch 库，如 import torch。
- absolute value = torch . tensor([5，4]，dtype=torch.float64): 这里我们用 float 类型创建角度的绝对长度。
- print(torch . polar(absolute value，angle)) 用于构造复张量。
# Importing libraries
import torch
import numpy
# Creating the absolute lengths of angle with float type
absolutevalue = torch.tensor([5, 4], dtype=torch.float64)
# Creating the angles with float type
angle = torch.tensor([numpy.pi / 4, numpy.pi / 6],
dtype=torch.double)
# Construct the complex tensor
print(torch.polar(absolutevalue, angle))
# Construct the complex tensor and display the datatype
print(torch.polar(absolutevalue, angle).dtype)
输出:
在下面的输出中，我们可以看到 Pytorch 极坐标使用 double 类型创建角度，并使用打印在屏幕上的 float 类型值构造复杂张量。
PyTorch polar create angles with double type and construct complex tensor with float type
这样，我们就理解了 PyTorch 极坐标用 double 型生成角，用 float 型构造复张量。
Pytorch polar 构造了一个 dtype 的复张量为 torch.complex64，具有张量的绝对长度和角度
在这一节中，我们将学习 PyTorch 极坐标构造的一个复张量，dtype 是 torch.complex64，具有张量的绝对长度和角度。
这里我们使用 torch.polar()函数，从该函数中我们构造了 id torch.complex64 数据类型的复张量，具有张量的绝对长度和角度。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch 和 import numpy。
- absolute value = torch . tensor([4，6]，dtype=torch.float32) 用于定义复张量的绝对值。
- print("绝对值:"，absolutevalue) 用于打印绝对值。
- polar = torch . polar(absolute value，ang): 这里我们调用的是 polar()函数。
- print("复数的 dtype:\ n "，polar.dtype) 用于打印复数的类型。
# Import library
import torch
import numpy as np
# Define the absolute value of the complex tensor
absolutevalue = torch.tensor([4,6], dtype=torch.float32)
# Define the angle of the complex tensor
ang = torch.tensor([np.pi / 4, np.pi / 6], dtype=torch.float32)
# Print the absolute value and angle
print("absolute value:", absolutevalue)
print("ang:", ang)
polar = torch.polar(absolutevalue, ang)
print("Complex number:\n",polar)
print("dtype of complex number:\n", polar.dtype)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch polar 构造了一个 dtype 为 torch.complex64 的复张量。
PyTorch polar constructed a complex tensor of dtype is torch complex64 with absolute length and angle of tensor
这样，我们就可以理解 PyTorch 极构作了一个 dtype 的复张量是 torch complex64，具有张量的绝对长度和角度。
阅读: PyTorch 全连接层
Pytorch polar 构造了一个 dtype 的复张量为 torch.complex128，具有张量的绝对长度和角度
在这一节中，我们将了解 PyTorch 极坐标构造的一个复张量 dtype 是 torch.complex128，具有张量的绝对长度和角度。
在这里，我们使用 torch.polar()函数，从该函数中，我们用张量的绝对长度和角度来构造数据类型 id torch.complex128 的复张量。
代码:
在下面的代码中，我们将导入所需的库，如 import torch 和 import numpy。
- ang = torch.tensor([np.pi / 4，5 * np.pi / 6]，dtype=torch.float64) 用于定义复张量的角度。
- plr = torch.polar(absolute value，ang): 这里我们调用的是 torch . polar()函数。
- print(" dtype of complex number:\ n "，plr.dtype) 用于打印复杂数据类型的类型。
# Import library
import torch
import numpy as np
# Define the absolute value of the complex tensor
absolutevalue = torch.tensor([3, 5], dtype=torch.float64)
# Define the angle of the complex tensor
ang = torch.tensor([np.pi / 4, 5 * np.pi / 6], dtype=torch.float64)
# Calling the torch.polar() function
plr = torch.polar(absolutevalue, ang)
print("Complex number: \n",plr)
print("dtype of complex number:\n", plr.dtype)
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到 PyTorcvh 极坐标构造 dtype 的复张量是 torch.complex128 值打印在屏幕上。
Pytorch polar constructed a complex tensor of dtype is torch.complex128 with absolute length and angle of tensor
这就是我们对 Pytorch 极的理解，它构造了一个 dtype 的复张量，它是 torch.complex128，具有张量的绝对长度和角度。
另外，看看更多 Python 中的 PyTorch 教程。
因此，在本教程中，我们讨论了 PyTorch Polar ,我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- 什么是 PyTorch polar
- PyTorch polar()示例
- PyTorch polar 用浮点类型创建角度，用数据类型构造复张量
- 如何使用 PyTorch 极坐标
- PyTorch 极坐标用 double 类型创建角度，用 data 类型构造复张量
- PyTorch 极坐标用 double 型创建角度，用 float 型构造复张量
- Pytorch polar 构造了一个 dtype 为 torch.complex64 的复张量，具有张量的绝对长度和角度
- Pytorch polar 构造了一个 dtype 为 torch.complex128 的复张量，具有张量的绝对长度和角度
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch 预训练模型
在这个 Python 教程中，我们将了解 PyTorch 预训练模型，我们还将涵盖与 PyTorch 预训练模型相关的不同示例。我们将讨论这些话题。
- PyTorch 预训练模型
- PyTorch 预训练模型示例
- PyTorch 预训练模型特征提取
- PyTorch 预训练模型 cifar 10
- PyTorch 预训练模型负载
- PyTorch 预训练模型移除最后一层
- PyTorch 预训练模型归一化
- PyTorch 预处理修改最后一层
- PyTorch 预训练模型更改输入大小
- PyTorch 预训练模型添加层
- PyTorch 预训练模型微调
- PyTorch 预训练模型图像分类
- PyTorch 预训练模型推理
目录
- PyTorch 预训练模型
- PyTorch 预训练模型示例
- PyTorch 预训练模型特征提取
- PyTorch 预训练模型 cifar 10
- PyTorch 预训练模型负载
- PyTorch 预处理模型移除最后一层
- PyTorch 预训练模型归一化
- PyTorch 预处理修改最后一层
- PyTorch 预训练模型改变输入尺寸
- PyTorch 预训练模型添加图层
- PyTorch 预训练模型微调
- PyTorch 预处理模型图像分类
- PyTorch 预训练模型推理
PyTorch 预训练模型
在这一节中，我们将学习 python 中的 PyTorch 预训练模型。
- 在继续之前，我们应该有一个关于预训练模型的知识。
- 预训练模型被定义为在标准数据集(如 ImageNet)上训练的神经网络模型。
代码:
在下面的代码中，我们将导入 pretrainedmodels 模块，从中我们可以在标准数据集上训练模型。
print(pretrained models . model _ names)用于打印预训练的模型数据。- 模型=预训练模型。_ _ dict _ _[model name](num _ classes = 1000，pretrained='imagenet') 用于加载预训练的模型。
models.eval()用于评估模型。
import pretrainedmodels
print(pretrainedmodels.model_names)
print(pretrainedmodels.pretrained_settings['nasnetalarge'])
modelname = 'nasnetalarge'
models = pretrainedmodels.__dict__[modelname](num_classes=1000, pretrained='imagenet')
models.eval()
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到预训练的模型数据被打印在屏幕上。
PyTorch pretrained model
另外，检查: PyTorch 保存模型
PyTorch 预训练模型示例
在本节中，我们将通过 python 中的示例了解 PyTorch 预训练模型。
- 预训练模型是指已经在一些数据集上训练过的深度学习架构。
- 预训练模型是在 alexnet、ImageNet 等标准数据集上训练的神经网络模型。
代码:
在下面的代码中，我们将导入一些库，通过示例的帮助，我们可以在标准数据集上训练模型。
dir(model)用于在屏幕上显示不同的模型和架构。Alex net = model . Alex net(pre trained = True)用作预训练模型。print(alexnet)用于打印预训练模型的数据。
from torchvision import models as model
import torch
dir(model)
alexnet = model.alexnet(pretrained=True)
print(alexnet)
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到预训练模型的数据被打印在屏幕上。
PyTorch pretrained model example
PyTorch 预训练模型特征提取
在本节中，我们将了解如何在 python 中的预训练模型中完成特征提取。
特征提取被定义为降维的过程，通过该过程，原始数据的初始集合被减少到更可实现的组以便处理。
代码:
在下面的代码中，我们将导入一些库，从中我们可以从预训练的模型中提取特征。
rn18 = model . resnet 18(pre trained = True)用作预训练模型。- print("Children Counter:"，Children_Counter，" Layer Name:"，I，)用于打印子计数器和层名称。
- rn18。_modules 用于在屏幕上显示模块。
import torch
import torch.nn as nn
from torchvision import models as model
rn18 = model.resnet18(pretrained=True)
Children_Counter = 0
for i,j in rn18.named_children():
print("Children Counter: ",Children_Counter," Layer Name: ",i,)
Children_Counter+=1
rn18._modules
输出:
在下面的输出中，我们可以看到该特征可以由预训练的模型提取并打印在屏幕上。
PyTorch pretrained model feature extraction
PyTorch 预训练模型 cifar 10
在本节中，我们将学习 python 中的 PyTorch 预训练模型 cifar 10 。
- CiFAR-10 是一个数据集，它是一个数据集合，通常用于训练机器学习，也用于计算机版本算法。
- 在这里，我们可以使用在 cifar 10 等标准数据集上训练的预训练模型，cifar 代表加拿大高级研究所。
代码:
在下面的代码中，我们将把 torch 库导入到 cifar-10 等标准的预训练模型中。
- 从 pprint 导入 pprint as print 用于以 python 数据结构的形式美化打印，该数据结构可用作解释器的输入。
- print(torch . hub . list(" chenyaofo/py torch-cifar-models "，force_reload=True)) 用于打印并重新加载屏幕数据。
import torch
from pprint import pprint as print
print(torch.hub.list("chenyaofo/pytorch-cifar-models", force_reload=True))
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 cifar 模型数据被打印在屏幕上。
PyTorch pretraied cifar10
读取 PyTorch 模型评估
PyTorch 预训练模型负载
在这一节中，我们将学习如何在 python 中加载预训练模型。
- 预训练模型定义为在合适的数据集(如 AlexNet、ImageNet 等)上训练的神经网络模型。
- 研究人员可以使用这些预训练的模型，而不是从头再来。
- 在这里，我们可以使用预训练模型并加载预训练模型的数据。
代码:
在下面的代码中，我们将导入在合适的数据集上训练的预训练模型，并加载数据。
print(pretrained models . model _ names)用于打印预训练的模型名称。- 模型=预训练模型。_ _ dict _ _[model name](num _ classes = 1000，pretrained='imagenet') 用于加载模型。
models.eval()用于评估模型。
import pretrainedmodels
print(pretrainedmodels.model_names)
print(pretrainedmodels.pretrained_settings['vgg11'])
modelname = 'vgg11'
models = pretrainedmodels.__dict__[modelname](num_classes=1000, pretrained='imagenet')
models.eval()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 预训练的模型数据被加载到屏幕上。
PyTorch pretrained model load
读取 PyTorch 提前停止
PyTorch 预处理模型移除最后一层
在第节中，我们将了解到 PyTorch 预训练模型移除了 python 中的最后一层。
- 预训练模型在合适的数据集上训练，这里我们要删除训练模型的最后一层。
- 从预训练模型中移除最后一层后，屏幕上会生成新数据。
代码:
在下面的代码中，我们将导入一些库，从中我们可以删除预训练模型的最后一层。
models . resnet 152(pre trained = True)用作预训练模型。- 打印(重塑)用于打印模型。
list(premodel.modules())用于检查模型的模块。- nn。sequential( list(pre model . modules())[:-1])*用于接受任何输入，快速实现顺序模块。
- mymodel = nn。sequential( list(pre model . modules())[:-1])*用于删除最后一层。
- 打印(mymodel) 用于打印模型。
from torchvision import datasets, transforms, models
premodel = models.resnet152(pretrained=True)
print(premodel)
list(premodel.modules())
mymodel = nn.Sequential(*list(premodel.modules())[:-1])
premodel = models.resnet152(pretrained=True)
list(premodel.modules())
mymodel = nn.Sequential(*list(premodel.modules())[:-1])
print(mymodel)
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到最后一层从预训练模型中移除，修改后的预训练模型打印在屏幕上。
PyTorch pretrained model remove the last layer
PyTorch 预训练模型归一化
在本节中，我们将学习 python 中的 PyTorch 预训练模型规范化。
PyTorch 中的规范化是使用torch vision . transform . normalization()完成的。这用于使用平均值和标准偏差对数据进行标准化。
代码:
在下面的代码中，我们将导入一些库，从中我们可以规范化我们的预训练模型。
- 数据集=数据集。MNIST(“数据”，下载=真，训练=真，变换=变换。【ToTensor()】用于转换数据集。
- 正常化=转换。Normalize(mean=[0.495，0.467，0.418]，std=[0.239，0.324，0.235]) 用于对数据进行归一化处理。
mean = torch.zeros(1)用于计算平均值。std = torch.zeros(1)用于计算标准差。- 打印('计算平均值和标准差')用于打印计算平均值和标准差。
import os
import torch
from torchvision import datasets, transforms
from torch.utils.data.dataset import Dataset
from tqdm.notebook import tqdm
from time import time
nchanels = 1
ds = datasets.MNIST("data", download=True,
train=True, transform=transforms.ToTensor())
normalize = transforms.Normalize(mean=[0.495, 0.467, 0.418],
std=[0.239, 0.324, 0.235])
fulldr = torch.utils.data.DataLoader(ds, shuffle=False, num_workers=os.cpu_count())
mean_val = torch.zeros(1)
std_val = torch.zeros(1)
print('Calculating mean_val and std_val')
for input, lbls in tqdm(fulldr):
for x in range(nchanels):
mean_val[x] += input[:,x,:,:].mean()
std_val[x] += input[:,x,:,:].std()
mean_val.div_(len(ds))
std_val.div_(len(ds))
print(mean_val, std_val)
输出:
在下面的输出中，我们可以看到平均值和标准偏差打印在屏幕上，对 PyTorch 预训练模型进行标准化。
PyTorch pretrained model normalization
PyTorch 预处理修改最后一层
在这一节中，我们将学习如何用 python 修改 PyTorch 预训练模型的最后一层。
- 预训练模型是在合适的数据集(如 ImageNet、Alexnet 等)上训练的神经网络模型。
- 在这里，我们可以修改预训练模型的最后一层，我们可以用新层替换最后一层。
代码:
在下面的代码中，我们将导入一些库，从中我们可以修改最后一层。
vgg 16 = model . vgg 16(pre trained = True)用作预训练模型。- 打印(vgg16。_modules.keys()) 用于打印模型。
- 打印(vgg16。_modules['classifier']) 用于打印分类器。
outfeatures = 100与 100 个其他类别一起用于此型号。- 打印(vgg16。_modules['classifier']) 用于打印新的最后一层分类器。
import torch
import torch.nn as nn
import torchvision.models as model
vgg16 = model.vgg16(pretrained=True)
print(vgg16._modules.keys())
print(vgg16._modules['classifier'])
infeatures = vgg16._modules['classifier'][-1].in_features
outfeatures = 100
vgg16._modules['classifier'][-1] = nn.Linear(infeatures, outfeatures, bias=True)
print(vgg16._modules['classifier'])
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到 PyTorch 预训练模型修改了屏幕上打印的最后一层。
PyTorch pretrained model modify the last layer
PyTorch 预训练模型改变输入尺寸
在这一节中，我们将学习如何在 python 中改变 PyTorch 预训练模型的输入大小。
预训练模型被定义为在合适的数据集上训练的神经网络模型，并且我们也可以改变模型输入大小。
代码:
在下面的代码中，我们将导入一些模块，从中我们可以更改预训练模型的输入大小。
- X = torch.randn(1，1，224，224) 用于生成随机数。
- model = model . vgg 16(pre trained = False):pre trained = False 只是出于调试原因而使用。
- firstconvlayer = [nn。Conv2d(1，3，kernel_size=3，stride=1，padding=1，dilation=1，groups=1，bias=True)] 用于制作第一个卷积层。
firstconvlayer . extend(list(model . features))用于扩展图层。- nn。Sequential(*firstconvlayer ) 用于实现顺序模块。
- print(输出)用于在屏幕上打印输出。
import pretrainedmodels
import torchvision.models as model
import torch
import torch.nn as nn
X = torch.randn(1, 1, 224, 224)
model = model.vgg16(pretrained=False)
firstconvlayer = [nn.Conv2d(1, 3, kernel_size=3, stride=1, padding=1, dilation=1, groups=1, bias=True)]
firstconvlayer.extend(list(model.features))
model.features= nn.Sequential(*firstconvlayer )
output = model(X)
print(output)
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到预训练模型的输入大小的变化被打印在屏幕上。
PyTorch pretrained model change input size
PyTorch 预训练模型添加图层
在本节中，我们将了解如何在 PyTorch 预训练模型中添加层。
PyTorch 预训练模型是经过 Imagenet 等大型数据集训练的神经网络模型。
在这里，我们可以在预训练的模型中添加一个新层来制作一个新模型。
代码:
在下面的代码中，我们将导入一些模块，从中我们可以在预训练模型中添加一个层。
- nn。顺序(nn。线性(1000，100)，nn。ReLU()，nn。(100，4))用于实现顺序模块。
X = self . pre trained _ model(X)用于对模型进行预训练。X = self.new_layers(X)用于添加新层。extended _ model = Alex net(pre trained _ model = pre trained _ model)用于扩展模型。
import torchvision
import pretrainedmodels
from torchvision import models
pretrained_model = torchvision.models.alexnet(pretrained=True)
class AlexNet(nn.Module):
def __init__(self, pretrained_model):
super(AlexNet, self).__init__()
self.pretrained = pretrained_model
self.new_layers = nn.Sequential(nn.Linear(1000, 100),
nn.ReLU(),
nn.Linear(100, 4))
def forward(self, X):
X = self.pretrained_model(X)
X = self.new_layers(X)
return X
extended_model = AlexNet(pretrained_model=pretrained_model)
extended_model
输出:
在下面的输出中，我们可以看到新层被添加到预训练模型中，并且新层的数据被打印在屏幕上。
PyTorch pretrained model add layer
PyTorch 预训练模型微调
在本节中，我们将学习 python 中的 PyTorch 预训练模型微调。
在前进之前，我们应该有一个关于微调的知识。微调被定义为达到最佳或期望性能的过程。
在这里，我们希望获得预训练模型 PyTorch 的最佳性能。
代码:
在下面的代码中，我们将导入一些模块，从中我们可以获得模型的最佳性能。
- 打印(" PyTorch 版本: "，Torch。version) 用于打印火炬的版本，在其上我们得到了模型的最佳性能。
- print("Torchvision 版本: "，Torchvision。version) 用于在屏幕上打印火炬视觉版本。
from __future__ import print_function
from __future__ import division
import torch
import torch.nn as nn
import torch.optim as optimize
import numpy as num
import torchvision
from torchvision import datasets, models, transforms
import matplotlib.pyplot as plot
import time
import os
import copy
print("PyTorch version: ",torch.__version__)
print("Torchvision version: ",torchvision.__version__)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 和 torchvision 的版本打印在屏幕上，我们可以在它上面获得模型的最佳性能。
PyTorch pretrained model fine-tune
阅读: PyTorch 超参数调谐
PyTorch 预处理模型图像分类
在本节中，我们将学习 python 中的 PyTorch 预训练模型图像分类。
- 预训练模型是在大型数据集上训练的神经网络，如 ImageNet、AlexNet 等。
- 预训练模型是计算机视觉研究快速发展的重要因素。
代码:
在下面的代码中，我们将导入一些库，从中我们可以进行预训练的模型图像分类。
Alex net = model . Alex net(pre trained = True)作为预训练模型。- 打印(alexnet) 用于打印 alexnet。
image = image . open(" dog . jfif ")用于打开图片。plt.imshow(image)用于在屏幕上绘制图像。image_t = transform(image)用作变换图像。
from torchvision import models as model
import torch
import matplotlib.pyplot as plt
dir(model)
alexnet = model.alexnet(pretrained=True)
print(alexnet)
from torchvision import transforms
transform = transforms.Compose([
transforms.Resize(258),
transforms.CenterCrop(226),
transforms.ToTensor(),
transforms.Normalize(
mean=[0.487, 0.458, 0.408],
std=[0.232, 0.226, 0.227]
)])
from PIL import Image
image = Image.open("dog.jfif")
plt.imshow(image)
image_t = transform(image)
batch_t = torch.unsqueeze(image_t, 0)
输出:
在下面的输出中，我们可以看到预训练的模型训练数据和预训练的模型图像分类都是在屏幕上完成的。
PyTorch pretrained model image classification
PyTorch 预训练模型推理
在本节中，我们将学习 python 中的 PyTorch 预训练模型推理。
推理被定义为关注如何使用预训练模型来预测输入类别的过程。
代码:
在下面的代码中，我们将导入一些库，从中我们可以预训练模型推理。
dir(model)用于返回属性列表。Alex net = model . Alex net(pre trained = True)使用的是预训练模型。alexnet.eval()用于评估预训练模型。print(output.shape)用于在屏幕上打印输出。
from torchvision import models as model
import torch
dir(model)
alexnet = model.alexnet(pretrained=True)
alexnet.eval()
output = alexnet(batch_t)
print(output.shape)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 预训练的模型推理被打印在屏幕上。
PyTorch pretrained model inference
因此，在本教程中，我们讨论了 Py 到 rch 预训练模型，我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch 预训练模型
- PyTorch 预训练模型示例
- PyTorch 预训练模型特征提取
- PyTorch 预训练模型 cifar 10
- PyTorch 预训练模型负载
- PyTorch 预训练模型移除最后一层
- PyTorch 预训练模型归一化
- PyTorch 预处理修改最后一层
- PyTorch 预训练模型更改输入大小
- PyTorch 预训练模型添加层
- PyTorch 预训练模型微调
- PyTorch 预训练模型图像分类
- PyTorch 预训练模型推理
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch 整形张量-有用的教程
在本 Python 教程中，我们将学习 Python 中的 PyTorch 重塑张量 。整形允许我们转换具有相似数据和元素数量的形状，这意味着它返回与识别的数组相同的数据，但具有不同的识别维度大小。
此外，我们还将涵盖与 PyTorch 整形张量相关的不同示例。我们将讨论这些话题。
- PyTorch 整形张量
- PyTorch 整形张量示例
- PyTorch 重塑张量视图
- PyTorch 将一维张量整形为二维张量
- PyTorch 将张量整形为 4 行 2 列
- PyTorch 将张量整形为 8 行 1 列
目录
- PyTorch 整形张量
- PyTorch 整形张量示例
- PyTorch 重塑张量视图
- PyTorch 将一维张量整形为二维张量
- PyTorch 将张量整形为 4 行 2 列
- 列
- PyTorch 将张量整形为 8 行 1 列
PyTorch 整形张量
在本节中，我们将学习 python 中的 PyTorch 整形张量。
Reshape 允许我们转换具有相似数据和元素数量的形状，这意味着它返回与识别的数组相同的数据，但具有不同的识别维度大小。
语法:
PyTorch 整形张量的语法:
torch.reshape(input,shape)
参数:
以下是 PyTorch 整形张量的参数
- 输入:输入参数作为要整形的张量。
- 形状:形状参数被用作新的形状。
至此，我们已经了解了 PyTorch 整形张量。
阅读: PyTorch 超参数调谐
PyTorch 整形张量示例
在本节中，我们将借助 python 中的一个例子了解如何实现 PyTorch reshape 张量。
shape()函数返回具有相似数据和元素数量的张量作为输入，但具有已识别的形状。
当可行时，返回的张量将是输入的视图。具有一致步幅的恒定输入可以在不复制的情况下被重新整形。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch 和 import torch.nn。
- a = torch.arange。)用于通过 torch.arange()函数声明变量。
- torch . shape(a，(3，2)): 这里我们使用了 shape()函数，在这个函数中，我们使用了一些参数，比如输入和形状。
#Importing Libraries
import torch
import torch. nn as nn
# Describing the variable
a = torch.arange(6.)
# Using reshaping() method
torch.reshape(a, (3, 2))
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到 PyTorch 整形张量值打印在屏幕上。
PyTorch reshape tensor example
这样，我们借助一个例子，了解了 PyTorch 整形张量。
PyTorch 重塑张量视图
在本节中，我们将了解 python 的 PyTorch 重塑张量视图。
PyTorch 整形张量视图被定义为返回与自张量具有相同数据但形状不同的新张量的过程。
它返回张量并分配相似的数据，应该有相同数量的元素，但可能有不同的大小。
代码:
在下面的代码中，我们将导入所有必要的如 import torch 和 import torch.nn。
- s = torch.tensor([[1，2]，[3，4]]): 这里我们用 torch.tensor()函数来描述 s 变量。
- torch . shape(s，(-1，)):这里我们使用了 torch . shape()函数，在这个函数中，我们使用了一些参数，比如输入和形状。
a = s.view(4)这里我们使用 view()函数返回一个新的张量，该张量具有与自张量相同的数据，但形状不同。print(a)用于通过 print()函数打印变量。
# Importing Libraries
import torch
import torch. nn as nn
# Describe a variable
s = torch.tensor([[1, 2], [3, 4]])
# Using reshape() method
torch.reshape(s, (-1,))
# Using View() function
a = s.view(4)
print(a)
输出:
运行上述代码后，我们得到以下输出，可以看到 PyTorch reshape tensor 视图打印在屏幕上。
PyTorch reshape tensor view
这就是我们使用 PyTorch reshape 视图的方式。
阅读: PyTorch 激活功能
PyTorch 将一维张量整形为二维张量
在本节中，我们将学习 python 中的 PyTorch reshape tensor 一维张量到二维张量。
整形方法用于将张量整形为给定的形状。这里，我们把一维张量改造成二维张量。
或者可以说，借助于整形方法，一维张量可以转化为二维张量。
代码:
在下面的代码中，首先我们导入 torch 库，比如 import torch。
- r = torch.tensor([2，4，6，8，10，12]): 这里我们创建一个包含 6 个元素的一维张量。
- print(r.shape): 这里我们借助 print()函数显示张量形状。
- print(r): 这里我们在 print()函数的帮助下显示实际的张量。
- print(r . shape([3，2]):这里我们将张量整形为三行两列。
- print(r.shape): 这里我们使用 print()函数显示一个整形张量的形状。
# Import linrary
import torch
# Create an 1 D tensor with 6 elements
r = torch.tensor([2, 4, 6, 8, 10, 12])
# Display tensor shape
print(r.shape)
# Display actual tensor
print(r)
# Reshape tensor into 3 rows and 2 columns
print(r.reshape([3, 2]))
# Display shape of reshaped tensor
print(r.shape)
输出:
运行上面的代码后，我们得到了下面的输出，其中我们可以看到 PyTorch 将一个维度的张量整形为打印在屏幕上的两个维度的张量。
PyTorch reshape one dimension tensor to two dimension tensor
这样，我们就理解了 PyTorch 把一维张量改造成二维张量。
阅读: PyTorch MNIST 教程
PyTorch 将张量整形为 4 行 2 列
列
在这一节中，我们将学习 python 中的 PyTorch 将张量整形为 4 行 2 列。
整形方法用于将张量整形为给定的形状。在这里，我们将张量重塑为四行两列。
代码:
在下面的代码中，首先我们将导入 torch 库，如 import torch。
- r = torch.tensor([2，4，6，8，10，12，14，16]): 这里我们创建一个有八个元素的一维张量。
- print(r.shape): 这里我们使用 print()函数显示一个张量形状。
- print(r . shape([4，2]):这里我们把张量整形为四行两列。
- print(r.shape): 这里我们借助 print()函数显示形状。
# import torch module
import torch
# Creating an one Dimensional tensor with Eight elements
r = torch.tensor([2, 4, 6, 8, 10, 12, 14, 16])
# Showing tensor shape
print(r.shape)
# Showing actual tensor
print(r)
# Reshape tensor into Four rows and Two columns
print(r.reshape([4, 2]))
# Showing the shape
print(r.shape)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 将张量重新整形为 4 行 2 列。
PyTorch reshape tensor into 4 rows and 2 columns
这样，我们理解了 PyTorch 整形张量为 4 行 2 列。
阅读: PyTorch 车型总结
PyTorch 将张量整形为 8 行 1 列
在这一节中，我们将学习 python 中的 PyTorch 将张量整形为 8 行 和 1 列。
整形方法用于将张量整形为给定的形状。在这里，我们将张量整形为八行一列。
代码:
在下面的代码中，首先我们将导入 torch 库，如 import torch。
- r = torch.tensor([2，4，6，8，10，12，14，16]): 这里我们创建一个有八个元素的一维张量。
- print(r.shape): 这里我们使用 print()函数显示一个张量形状。
- print(r): 这里我们在 print()函数的帮助下显示实际的张量。
- print(r . shape([8，1]):这里我们将张量整形为八行一列。
- print(r.shape): 这里我们借助 print()函数显示形状。
# import torch module
import torch
# Creating an one Dimensional tensor with Eight elements
r = torch.tensor([2, 4, 6, 8, 10, 12, 14, 16])
# Showing tensor shape
print(r.shape)
# Showing the actual tensor
print(r)
# Reshapeing teh tensor into eight rows and one column
print(r.reshape([8, 1]))
# Showing the shape
print(r.shape)
输出:
运行上面的代码后，我们得到了下面的输出，其中我们可以看到 PyTorch 将一个张量整形为 8 行 1 列并打印在屏幕上。
PyTorch reshape a tensor into 8 rows and 1 column
因此，我们了解了 PyTorch 将张量整形为 8 列 1 行。
另外，再看看一些 PyTorch 教程。
因此，在本教程中，我们讨论了 PyTorch Reshape Tensor ，并且我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch 整形张量
- PyTorch 整形张量示例
- PyTorch 重塑张量视图
- PyTorch 将一维张量整形为二维张量
- PyTorch 将张量整形为 4 行 2 列
- PyTorch 将张量整形为 8 行 1 列
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch 调整图像大小
在 PyTorch 中，Resize()函数用于将输入图像调整到指定的大小。torchvision.transforms 模块提供各种图像变换。具体来说，我们将讨论在 Python 中使用 PyTorch 调整图像大小的。
此外，我们还将介绍与 PyTorch resize images 相关的不同示例。我们将讨论这些话题。
- PyTorch resize image
- PyTorch 调整图像大小示例
- PyTorch 如何调整图像张量的大小
- PyTorch 如何调整图像变换的大小
- PyTorch resize 3d image
- PyTorch 如何在 GPU 上调整图像大小
- PyTorch resize image batch
- PyTorch 如何调整输入图像的大小
目录
- PyTorch 调整图像大小
- PyTorch 调整图像大小示例
- 【PyTorch 如何调整图像张量的大小
- 【PyTorch 如何调整图像大小变换
- PyTorch 调整 3d 图像大小
- 【PyTorch 如何在 GPU 上调整图像大小
- PyTorch 调整图像大小批次
- 【PyTorch 如何调整输入图像的大小
PyTorch 调整图像大小
在这一节中，我们将学习如何使用 python 中的 resize()函数来调整图片的大小。
Resize()函数用于将输入图像的大小调整到指定的大小。此转换通过 torchvision.transforms 模块提供各种转换。
语法:
PyTorch 调整图像大小的语法:
torchvision.transforms.Resize(size)
参数:
以下是 PyTorch 调整图像大小的参数:
Size: Size 是输入图像要调整大小的参数。size 是一个类似(h，w)的序列，其中 h 是批中输出图像的高度，w 是其重量。如果图像的大小是 int 格式，那么调整大小后图像的大小将是一个正方形图像。
至此，我们了解了 PyTorch 使用 resize()函数调整图像大小。
PyTorch 调整图像大小示例
在本节中，我们将学习如何借助 python 中的一个示例来实现 PyTorch resiz e 图像。
torchvision.transforms 模块提供各种图像变换。有一个 Resize()函数用于将输入图像调整到指定的大小。Resize()函数接受 PIL 和张量图像。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch，import torch vision . transforms as T，import Image from PIL，import matplotlib.pyplot as plot。
- imge = image . open(' butterfly . png '):这里我们正在读取输入的图像。
size = imge.size用于计算图像的大小。- transforms = T . Resize(size =(200，400)) 用于定义给定大小的图像的变换或调整大小。
imge = transforms(imge)用于对输入图像应用变换。- print(" resize 后的尺寸:"，imge.size) 用于通过 print()函数打印 resize 后的尺寸。
# Importing Libraries
import torch
import torchvision.transforms as T
from PIL import Image
import matplotlib.pyplot as plot
# Read the input image
imge = Image.open('NewYork.png')
# Compute the size(width, height) of image
size = imge.size
print("The size of the original image:", size)
# Define transform or resize the image with given size
transforms = T.Resize(size = (200,400))
# Apply the transformation on the input image
imge = transforms(imge)
print("The size after resize:", imge.size)
plot.imshow(imge)
plot.show()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到调整大小后的图像的大小被打印在屏幕上。
这就是我们如何借助一个例子来理解 resize image 的实现。
【PyTorch 如何调整图像张量的大小
在这一节中，我们将学习 python 中的 PyTorch resize image tensor 。
图像张量被定义为具有形状(C，H，W)的 torch 张量。这里 C 代表通道的数量，H 代表图像高度，W 代表图像宽度。
Resize()函数用于将输入图像张量调整到指定的大小。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch，import torch vision . transforms as T，import Image from PIL，import matplotlib.pyplot as plot。
- image = image . open(' flower . jpg ')这里我们读取 PIL 的图像。
size = image.size用于计算图像的大小。- print("原始图像的尺寸:"，size) 用于打印原始图像的尺寸。
- 变换=转换。Resize(size = (300，500)) 用于定义变换或调整图像张量的大小。
image = transforms(image)用于对输入图像应用变换。- print(" resize 后的尺寸:"，image.size) 用于打印 resize 后的尺寸。
# import the required libraries
import torch
import torchvision.transforms as trans
from PIL import Image
import matplotlib.pyplot as plot
# Read the input image
image = Image.open('Chicago.jpg')
# compute the size of the image
size = image.size
print("The size of the original image:", size)
# Define transform or resize the image tensor
transforms = trans.Resize(size = (300,500))
# Apply the transformation on the input image
image = transforms(image)
print("The size after resize:", image.size)
plot.imshow(image)
plot.show()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到张量图像的大小被调整并打印在屏幕上。
PyTorch resize image tensor
这样，我们理解了 PyTorch 调整图像张量的大小。
阅读 PyTorch 堆栈教程
【PyTorch 如何调整图像大小变换
在这一节中，我们将学习 python 中的 PyTorch resize image 变换。
PyTorch 调整图像大小转换用于将输入图像调整到给定的大小。如果图像是 torch 张量，那么它具有 H，W 形状。
语法:
PyTorch 调整图像大小转换的语法:
torchvision.transforms.Resize(size, interpollation=InterpolationMode.BILINEAR, max_size=None, antialias=None)
参数:
- 尺寸:尺寸定义为所需的输出尺寸。大小是一个类似(h，w)的序列，其中 h 是批中输出图像的高度，w 是其重量。如果图像的大小是 int 格式，那么调整大小后图像的大小将是一个正方形图像。
- 插值:所需的插值被定义为由 torch vision . transforms . interploationmode 定义的枚举。支持最近的。
- max_size: 被调整大小的图像的较大边缘所允许的最大尺寸。如果根据大小调整大小后，图像的较大边缘大于 max_size。
- 抗锯齿:如果图像是 PIL 图像，标志被忽略，抗锯齿总是被使用。如果图像是张量，默认情况下，该标志为假，并且可以为插值模式.双线性设置为真
这样，我们通过使用 torch vision . transform . shape()理解了 PyTorch resize 图像转换。
PyTorch 调整 3d 图像大小
在这一节中，我们将学习 python 中的 PyTorch resize 3d image 。
PyTorch resize 3d image 用于将 3d 图像调整到给定的大小。Resize()函数接受 PIL 和张量图像。
代码:
在下面的代码中，我们将导入所有必要的库，如导入 torch，导入 matplotlib.pyplot 作为 plot，导入 numpy 作为 np，从 torchvision 导入 transforms，从 PIL 导入 Image。
- image = image . open(' teddy . jpg ')用于读取 PIL 图像。
size = image.size用于计算图像的大小。- 变换=转换。Resize(size = (350，550)) 用于定义 3D 图像的变换或调整大小。
image = transforms(image)用于对输入图像进行变换。
# Importing Libraries
import torch
import matplotlib.pyplot as plt
import numpy as np
from torchvision import transforms
from PIL import Image
# Read a PIL Image
image = Image.open('Houston.jpg')
image
# Compute the size(width, height) of image
size = image.size
print(size)
# Define transform or resize the 3D image
transforms = transforms.Resize(size = (350,550))
# Use of the transformation on the input image
image = transforms(image)
print("The size after resize:", image.size)
plot.imshow(image)
plot.show()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 3D 图像的 resize 值被打印在屏幕上。
PyTorch resize 3d image
这就是我们如何理解 PyTorch 在 python 中调整 3D 图像的大小。
【PyTorch 如何在 GPU 上调整图像大小
在这一节中，我们将学习 python 中的 PyTorch 在 GPU 上调整图像大小。
在继续之前，我们应该了解一些关于 GPU 的知识。
GPU 代表图形处理单元，是一种经过训练的电子电路，旨在处理和改变内存，以增加图像的设计。
代码:
在下面的代码中，我们将导入所有必要的库，如导入 torch，导入 matplotlib.pyplot 作为 plot，导入 numpy 作为 np，从 torchvision 导入 transforms，从 PIL 导入 Image。
- Image = Image . open(' rose . jpg ')用于读取 PIL 图像。
device = torch . device(" cuda " if torch . cuda . is _ available()else " CPU ")用于定义路径和设置 GPU。size = image.size用于计算图像的大小。- 变换=转换。Resize(size = (450，650)) 用于定义在 GPU 上变换或调整一个图像的大小。
image = transforms(image)是对输入图像的变换。- print(" resize 后的尺寸:"，image.size) 用于打印 resize 后的尺寸。
# Importing Libraries
import torch
import matplotlib.pyplot as plot
import numpy as np
from torchvision import transforms
from PIL import Image
# Read a PIL Image
image = Image.open('San Diego.jpg')
image
# Define path and set GPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# Compute the size(width, height) of image
size = image.size
print(size)
# Define transform or resize the an image on GPU
transforms = transforms.Resize(size = (450,650))
# Use of the transformation on the input image
image = transforms(image)
print("The size after resize:", image.size)
plot.imshow(image)
plot.show()
输出:
在下面的输出中，您可以看到 PyTorch 在屏幕上打印的 GPU 上调整图像的大小。
PyTorch resize image on GPU
至此，我们了解了借助 resize()函数在 GPU 上调整 PyTorch 图像大小的方法。
PyTorch 调整图像大小批次
在这一节中，我们将学习 python 中的 PyTorch resize image batch 。
在继续之前，我们应该有一个关于批处理的知识。
批处理被定义为将事物安排在集合或组中的过程。这里我们使用 resize()函数批量调整图像的大小。
代码:
在下面的代码中，首先我们将导入所有必要的库，如 import torch，Import torch vision . transforms . functional，import Import from PIL。
- image = image . open(" Philadelphia . jpg "):我们在这里读取图像。
- print("实际图像大小:"，image.size，" \n") 用于借助 print()函数打印原始图像的大小。
- crop image = fn.center_crop(image，output_size=[450]) 用于通过使用 fn . center _ crop()来裁剪图像。
- resizeimage = fn.resize(image，size=[200]) 用于调整图像大小。
- print("调整后图像的尺寸:"，resizeimage.size，" \n") 用于打印调整后图像的尺寸。
# Import Library
import torch
import torchvision.transforms.functional as fn
from PIL import Image
# Read the image
image = Image.open("Philadelphia.jpg")
print("Size of actual image:",image.size, "\n")
image
# Crop the image
cropimage = fn.center_crop(image, output_size=[450])
print("Size of cropped image:",cropimage.size,"\n")
cropimage
# Resize the image
resizeimage = fn.resize(image, size=[200])
print("Size of resized image:",resizeimage.size,"\n")
resizeimage
输出:
运行上面的代码后，我们得到了下面的输出，其中我们可以看到实际图像的大小、裁剪后的图像和调整后的图像被打印在屏幕上。
PyTorch resize image batch
这就是我们如何理解 PyTorch 通过使用 Resize()函数以批处理的形式调整图像的大小。
阅读 PyTorch 展平
【PyTorch 如何调整输入图像的大小
在这一节中，我们将学习 python 中的 PyTorch resize 输入图像。
PyTorch 中有一个 Resize()函数，用于将输入图像的大小调整到指定的大小。此转换通过 torchvision.transforms 模块提供各种转换。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch，import requests，import torchvision.transforms，import Image from PIL。
image = image . open(" Philadelphia . jpg ")用于加载图片。- print("实际图像尺寸:"，image.size，" \n") 用于打印实际图像的尺寸。
- 预处理= T.Compose([ T.Resize(246)，T.CenterCrop(234) ]) 用作调整图像的大小。
- print("调整后图像的尺寸"，y.size，" \n") 用于通过 print()函数打印调整后图像的尺寸。
# Importing Libraries
import torch
import requests
import torchvision.transforms as T
from PIL import Image
# Read the image
image = Image.open("Philadelphia.jpg")
print("Size of actual image:",image.size, "\n")
image
# Resize the image
preprocess = T.Compose([
T.Resize(246),
T.CenterCrop(234)
])
y = preprocess(image)
print("Size of resized image" ,y.size,"\n")
y
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch resize 输入图像打印在屏幕上。
PyTorch resize input image
至此，我们了解了如何借助 Pytorch 中的 resize()函数来调整输入图像的大小。
因此，在本教程中，我们讨论了 PyTorch resize image ，并且我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch resize image
- PyTorch 调整图像大小示例
- 如何 PyTorch 调整图像张量
- PyTorch 如何调整图像变换的大小
- PyTorch resize 3d image
- PyTorch 如何在 GPU 上调整图像大小
- PyTorch resize image batch
- PyTorch 如何调整输入图像的大小
您可能会喜欢以下 PyTorch 教程:
我是一名机器学习工程师，目前作为一名 Python 开发人员在 Tsinfo Technologies 工作。我有使用各种 Python 库的经验，比如 Scikit learn、Turtle、PyTorch 等。
py torch RNN-详细指南
在这个 Python 教程中，我们将学习 Python 中的 PyTorch RNN ，我们还将涵盖与 PyTorch RNN 相关的不同例子。我们将讨论这些话题。
- PyTorch RNN
- PyTorch RNN 示例
- pytorch rnn 细胞
- PyTorch RNN 激活函数
- PyTorch RNN 二元分类法
- PyTorch RNN 情绪分析
- PyTorch RNN 语言模型
- pyzer rn 数据加载器
还有，查看最新 PyTorch 教程: PyTorch 激活功能
目录
- rn 指针
- PyTorch RNN 的例子
- rn 细胞探针的研究
- PyTorch RNN 激活功能
- PyTorch RNN 二元分类法
- PyTorch RNN 情绪分析
- PyTorch RNN 语言模型
- rn 数据加载器指针
rn 指针
在这一节中，我们将学习 python 中的 PyTorch RNN 模型。
RNN 代表 递归神经网络 它是一类利用时序数据或时间序列数据的人工神经网络。它主要用于顺序或时间问题。
语法:
PyTorch RNN 的语法:
torch.nn.RNN(input_size, hidden_layer, num_layer, bias=True, batch_first=False, dropout = 0, bidirectional = False)
参数:
- input_size: 在输入 x 中期望特征的数量。
- hidden_layer: 处于隐藏状态的特征数量。
- num _ layer:num _ layer 作为几个循环层使用。
- 偏差:如果偏差为假，则该层不使用偏差权重。
- batch_first: 如果 batch_first 为
True则提供输入和输出张量(批处理，序列，特征)而不是(序列，批处理，特征)。batch_first 的默认值为 False。 - 丢失:如果非零，在每个 RNN 层的输出上启动丢失层，不包括丢失概率等于丢失的最后一层。dropout 的默认值为 0。
- 双向:如果为真，则成为双向 RNN。双向的默认值为 False。
PyTorch RNN 的例子
在这一节中，我们将学习如何用 python 实现 PyTorch RNN 示例。
递归神经网络 是一种神经网络，其中来自前一步骤的输出被持续作为当前步骤的输入。
RNN 的重要特征是隐藏状态，即回忆序列的一些信息。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以计算 RNN 的输出。
- recnn = nn。RNN(12，22，4) 用于解决序列预测问题
- RNN。
- inp = torch.randn(7，5，12) 用于生成随机数作为输入。
- outp，hn = recnn(inp，h) 用于得到输出。
print(outp)用于在屏幕上打印输出。
import torch
import torch.nn as nn
recnn = nn.RNN(12, 22, 4)
inp = torch.randn(7, 5, 12)
h = torch.randn(4, 5, 22)
outp, hn = recnn(inp, h)
print(outp)
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到 PyTorch RNN 值打印在屏幕上。
PyTorch RNN example
阅读: PyTorch 批量标准化
rn 细胞探针的研究
在这一节中，我们将学习 python 中的 PyTorch RNN 单元。
RNN 单元是任何有状态的东西，它执行一些接受输入矩阵的操作。
RNN 细胞在某种意义上与系统神经元不同，它们有一种状态，可以记住过去的信息。
语法:
torch.nn.RNNCell(input_size, hidden_size, bias = True, nonlinearity = 'tanh', device = None, dtype = None)
参数:
input_size输入 x 中期望特征的数量。hidden_size处于隐藏状态的特征数为 h。- 偏差如果偏差为假，则该层不使用偏差权重。bias 的默认值为 True。
- 非线性度默认非线性度为 tanh。它可以是 tanh 或 relu。
PyTorch RNN 激活功能
在这一节中，我们将学习 python 中的 PyTorch RNN 激活函数。
PyTorch RNN 激活函数被定义为如何将输入的加权和转变为来自网络层中的一个或多个节点的输出。
代码:
在下面的代码中，我们将导入 torch 模块，rnn 模型的激活功能将从该模块开始工作。
- traindt = dtsets。MNIST(root= '。/data '，train=True，transform=transform。ToTensor()，download=True) 作为数据集使用。
self.hidendim = hidendim作为隐藏维度使用。self.layerdim = layerdim用作若干隐藏层。- self.rnn = nn。RNN(inpdim，hidendim，layerdim，batch_first=True，nonlinearity='relu') 用于建立 RNN 模型。
- self.fc = nn。linear(hidendim，outpdim)用作读出层。
- h = torch.zeros(self.layerdim，y.size(0)，self.hidendim)。requires_grad_() 用零初始化隐藏状态。
- outp = self.fc(outp[:，-1，😃作为上一次对象的索引隐藏状态。
- optim = torch . optim . SGD(MDL . parameters()、lr=l_r) 用于初始化优化器。
- imgs = imgs.view(-1，seqdim，inpdim)。requires_grad_() 用于将图像加载为带梯度的张量
optim.zero_grad()用作关于参数的清晰梯度。- loss = criter(outps，lbls) 用于计算损失。
optim.step()用作更新参数。outps = mdl(imgs)仅用作获取输出的前向传递。- _，predicted = torch.max(outps.data，1) 用于从最大值得到预测。
ttl += lbls.size(0)作为标签总数。- crrct +=(预测== lbls)。sum() 用作正确预测总数。
- 打印('迭代:{}。损失:{}。准确性:{} '。format(iter，loss.item()，accu)) 用于在屏幕上打印为精度。
import torch
import torch.nn as nn
import torchvision.transforms as transform
import torchvision.datasets as dtsets
traindt = dtsets.MNIST(root='./data',
train=True,
transform=transform.ToTensor(),
download=True)
testdt = dtsets.MNIST(root='./data',
train=False,
transform=transform.ToTensor())
batchsiz = 80
nitrs = 2800
numepoch = nitrs / (len(traindt) / batchsiz)
numepoch = int(numepoch)
trainldr = torch.utils.data.DataLoader(dataset=traindt,
batch_size=batchsiz,
shuffle=True)
testldr = torch.utils.data.DataLoader(dataset=testdt,
batch_size=batchsiz,
shuffle=False)
class rnn(nn.Module):
def __init__(self, inpdim, hidendim, layerdim, outpdim):
super(rnn, self).__init__()
self.hidendim = hidendim
self.layerdim = layerdim
self.rnn = nn.RNN(inpdim, hidendim, layerdim, batch_first=True, nonlinearity='relu')
self.fc = nn.Linear(hidendim, outpdim)
def forward(self, y):
h = torch.zeros(self.layerdim, y.size(0), self.hidendim).requires_grad_()
outp, hx = self.rnn(y, h.detach())
outp = self.fc(outp[:, -1, :])
return outp
inpdim = 28
hidendim = 80
layerdim = 1
outpdim = 10
mdl = rnn(inpdim, hidendim, layerdim, outpdim)
criter= nn.CrossEntropyLoss()
l_r = 0.01
optim = torch.optim.SGD(mdl.parameters(), lr=l_r)
list(mdl.parameters())[0].size()
seqdim = 28
itr = 0
for epoch in range(numepoch):
for x, (imgs, lbls) in enumerate(trainldr):
mdl.train()
imgs = imgs.view(-1, seqdim, inpdim).requires_grad_()
optim.zero_grad()
outps = mdl(imgs)
loss = criter(outps, lbls)
loss.backward()
optim.step()
itr += 1
if itr % 500 == 0:
mdl.eval()
crrct = 0
ttl = 0
for imgs, lbls in testldr:
imgs = imgs.view(-1, seqdim, inpdim)
outps = mdl(imgs)
_, predicted = torch.max(outps.data, 1)
ttl += lbls.size(0)
crrct += (predicted == lbls).sum()
accu = 100 * crrct / ttl
print('Iteration: {}. Loss: {}. Accuracy: {}'.format(iter, loss.item(), accu))
输出:
在下面的输出中，我们可以看到屏幕上显示了 rnn 模型的准确性。
PyTorch rnn activation function
PyTorch RNN 二元分类法
在这一节中，我们将学习 python 中的 PyTorch RNN 二进制分类。
二元分类可以预测一个或两个类别，或者涉及预测两个以上类别之一的多类别分类。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以借助二进制分类来预测一个或两个类。
- device = torch . device(' cuda ' if torch . cuda . is _ available()else ' CPU ')用作设备配置。
- nn。线性()用于创建一个前馈神经网络。
- modl = RNNModel(inpsize，hidsize，numlayrs，numclases)。至(设备)。用来(设备)初始化一个 RNN 模型。
- optim = optim。Adam(modl.parameters()，lr = 0.01) 用于初始化优化器。
- print(f " num _ epochs:{ nume pchs } ")用于打印历元数。
import torch
import torch.nn as nn
from torchvision import datasets as dtsets
from torchvision.transforms import ToTensor
traindt = dtsets.MNIST(
root = 'data',
train = True,
transform = ToTensor(),
download = True,
)
testdt = dtsets.MNIST(
root = 'data',
train = False,
transform = ToTensor()
)
from torch.utils.data import DataLoader
ldrs = {
'train' : torch.utils.data.DataLoader(traindt,
batch_size=100,
shuffle=True,
num_workers=1),
'test' : torch.utils.data.DataLoader(testdt,
batch_size=100,
shuffle=True,
num_workers=1),
}
ldrs
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
device
seqleng = 32
inpsize = 32
hidsize = 132
numlayrs = 6
numclases = 14
batchsiz = 100
numepchs = 6
l_r = 0.01
class RNNModel(nn.Module):
def __init__(self, inpsiz, hidsize, numlayrs, numclases):
super(RNNModel, self).__init__()
self.hidden_size = hidsize
self.num_layers = numlayrs
self.lstm = nn.LSTM(inpsize, hidsize, numlayrs, batch_first=True)
self.fc = nn.Linear(hidsize, numclases)
modl = RNNModel(inpsize, hidsize, numlayrs, numclases).to(device).to(device)
print(modl)
losfunc = nn.CrossEntropyLoss()
losfunc
from torch import optim
optim = optim.Adam(modl.parameters(), lr = 0.01)
optim
def train(numepchs, modl, ldrs):
print(f"num_epochs: {numepchs}")
print(f"model: {modl}")
print(f"loaders['train']: {ldrs['train']}")
train(numepchs, modl, ldrs)
输出:
在下面的输出中，我们可以看到 PyTorch RNN 二进制分类是在屏幕上完成的。
PyTorch RNN binary classification
阅读: PyTorch 全连接层
PyTorch RNN 情绪分析
在本节中，我们将学习 python 中的 PyTorch RNN 情感分析。
在继续之前，我们应该有一些关于情感分析的知识。
情绪分析 是一项预测建模任务，其中模型被训练来预测文本数据的二元性，如积极、消极或中性。
代码:
- characters = set("。join(text))用于将所有的句子连接在一起并提取出唯一的字符。
int 2 char = dict(enumerate(characters))用于将整数映射到字符。- inpseq . append(text[x][:-1])用于删除输入序列的最后一个字符。
- targseq . append(text[x][1:])用于从目标序列中删除第一个字符。
- features = np.zeros((batchsiz，seqleng，dicsiz)，dtype=np.float32) 创建具有所需输出形状的多维数组。
hiden = self . init _ hidden(batch siz)用于初始化隐藏状态。- modl = rnn model(inpsize = dicsiz，outpsize=dicsiz，hidendim=12，nlayrs=1) 用超参数实例化模型。
- optim = torch . optim . Adam(modl . parameters()、lr=l_r) 用于初始化优化器。
- print('Epochs: {}/{}…………'。格式(epoch，nepchs)，end=' ') 用于打印历元。
import torch
from torch import nn
import numpy as np
text = ['hey Guides','How are you','Have a nice day']
characts = set(''.join(text))
int2char = dict(enumerate(characts))
char2int = {char: ind for ind, char in int2char.items()}
maxleng = len(max(text, key=len))
for x in range(len(text)):
while len(text[x])<maxleng:
text[x] += ' '
inpseq = []
targseq = []
for x in range(len(text)):
inpseq.append(text[x][:-1])
targseq.append(text[x][1:])
print("Input Sequence: {}\nTarget Sequence: {}".format(inpseq[x], targseq[x]))
for i in range(len(text)):
inpseq[i] = [char2int[character] for character in inpseq[x]]
targseq[i] = [char2int[character] for character in targseq[x]]
dicsiz = len(char2int)
seqleng = maxleng - 1
batchsiz = len(text)
def one_hot_encode(sequen, dicsiz, seqleng, batchsiz):
features = np.zeros((batchsiz, seqleng, dicsiz), dtype=np.float32)
for x in range(batchsiz):
for y in range(seqleng):
features[x, y, sequen[x][y]] = 1
return features
inpseq = one_hot_encode(inpseq, dicsiz, seqleng, batchsiz)
inpseq = torch.from_numpy(inpseq)
target_seq = torch.Tensor(targseq)
is_cuda = torch.cuda.is_available()
if is_cuda:
device = torch.device("cuda")
print("gpu is available")
else:
device = torch.device("cpu")
print("gpu is not available, CPU used")
class RNNModel(nn.Module):
def __init__(self, inpsize, outpsize, hidendim, nlayrs):
super(RNNModel, self).__init__()
**# Defining some parameters**
self.hidendim = hidendim
self.nlayrs = nlayrs
**#Defining the layers**
self.rnn = nn.RNN(inpsize, hidendim, nlayrs, batch_first=True)
**# Fully connected layer**
self.fc = nn.Linear(hidendim, outpsize)
def forward(self, z):
batchsiz = z.size(0)
hiden = self.init_hidden(batchsiz)
outp, hiden = self.rnn(z, hiden)
outp = outp.contiguous().view(-1, self.hidendim)
outp = self.fc(outp)
return outp, hiden
def init_hidden(self, batchsiz):
hiden = torch.zeros(self.nlayrs, batchsiz, self.hidendim)
return hiden
modl = RNNModel(inpsize=dicsiz, outpsize=dicsiz, hidendim=12, nlayrs=1)
modl.to(device)
nepchs = 100
l_r=0.01
criter = nn.CrossEntropyLoss()
optim = torch.optim.Adam(modl.parameters(), lr=l_r)
for epoch in range(1, nepchs + 1):
optim.zero_grad()
inpseq.to(device)
outp, hiden = modl(inpseq)
loss = criter(outp, target_seq.view(-1).long())
loss.backward()
optim.step()
if epoch%10 == 0:
print('Epochs: {}/{}.............'.format(epoch, nepchs), end=' ')
print("Loss: {:.4f}".format(loss.item()))
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到 epochs 和 loss 被打印在屏幕上。
PyTorch RNN sentiment analysis
阅读: PyTorch MNIST 教程
PyTorch RNN 语言模型
在这一节中，我们将学习 python 中的 PyTorch RNN 语言模型。
- RNN 语言模型是一种在网络中带有 RNN 模型的神经网络语言模型。
- RNN 可以像在自然语言中一样对序列数据建模。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们了解了 RNN 学习模型。
- traindt = dtsets。MNIST(root='dataset/'，train=True，transform=transforms。ToTensor()，download=True) 用于加载数据集。
- modl = RNNlM(inpsize，hidensize，numlayrs，numclasses，sequlen)。【T1 到(device)】用于初始化 RNN 模型。
- optim = optim。Adam(modl.parameters()，lr=l_r) 用于初始化优化器。
- print(f ' got { num RCT }/{ num mples } with accuracy { float(num RCT)/float(num mples) 100:. 2f } ')modl . train()*用于打印模型的精度。
import torch
from tqdm import tqdm
import torch.nn as nn
import torch.optim as optim
import torchvision.datasets as dtsets
from torch.utils.data import DataLoader
from torchvision.transforms import transforms
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
**# Declaring Hyper-parameters**
inpsize = 28
sequlen = 28
numlayrs = 2
hidensize = 254
numclasses = 10
l_r = 0.001
batchsiz = 62
numepchs = 2
class RNNlM(nn.Module):
def __init__(self, inpsize, hidensize, numlayrs, numclasses, sequlen):
super(RNNlM, self).__init__()
self.hidensize = hidensize
self.numlayrs = numlayrs
self.lstm = nn.LSTM(inpsize, hidensize, numlayrs, batch_first=True)
self.fc = nn.Linear(hidensize*sequlen, numclasses)
def forward(self, data):
h = torch.zeros(self.numlayrs, data.size(0), self.hidensize).to(device)
c = torch.zeros(self.numlayrs, data.size(0), self.hidensize).to(device)
outp, _ = self.lstm(data, (h, c))
outp = outp.reshape(outp.shape[0], -1)
outp = self.fc(outp)
return outp
traindt = dtsets.MNIST(root='dataset/', train=True, transform=transforms.ToTensor(), download=True)
testdt = dtsets.MNIST(root='dataset/', train=False, transform=transforms.ToTensor(), download=True)
trainldr = DataLoader(dataset=traindt, batch_size=batchsiz, shuffle=True)
testldr = DataLoader(dataset=testdt, batch_size=batchsiz, shuffle=True)
modl = RNNlM(inpsize, hidensize, numlayrs, numclasses, sequlen).to(device)
criter = nn.CrossEntropyLoss()
optim = optim.Adam(modl.parameters(), lr=l_r)
**# Training Loop**
ep = 1
for epoch in tqdm(range(numepchs), desc=f'Training model for epoch {ep}/{numepchs}', total=numepchs):
for batch_idx, (data, trgt) in enumerate(trainldr):
data = data.to(device).squeeze(1)
trgts = trgt.to(device)
scores = modl(data)
loss = criter(scores, trgts)
optim.zero_grad()
loss.backward()
optim.step()
print(f'epoch: {epoch + 1} step: {batch_idx + 1}/{len(trainldr)} loss: {loss}')
ep += 1
**# Evaluating our RNN model**
def check_accuracy(ldr, modlrnnlm):
if ldr.dataset.train:
print('Check accuracy on training data')
else:
print('Check accuracy on test data')
numcrct = 0
numsmples = 0
modlrnnlm.eval()
with torch.no_grad():
for i,j in ldr:
i = i.to(device).squeeze(1)
j = j.to(device)
score = modlrnnlm(i)
_, predictions = score.max(1)
numcrct += (predictions == j).sum()
numsmples += predictions.size(0)
print(f'Got {numcrct}/{numsmples} with accuracy {float(numcrct)/float(numsmples)*100:.2f}')
modl.train()
check_accuracy(trainldr, modl)
check_accuracy(testldr, modl)
输出:
在下面的输出中，我们可以看到训练数据和测试数据的准确性被打印在屏幕上。
PyTorch RNN learning model
阅读: PyTorch 车型总结
rn 数据加载器指针
在这一节中，我们将学习 python 中的 PyTorch RNN 数据加载器。
数据集将训练或测试数据加载到内存中，或者数据加载器从数据集中获取数据，并将数据分批分发。
代码:
在下面的代码中，我们将导入 torch 模块，并从中加载 RNN 数据集。
- 班 RNN(nn。模块):用于定义 RNN 类。
- traindt =数据集。MNIST(root='dataset/'，train=True，transform=transforms。ToTensor()，download=True) 作为数据集使用。
- train ldr = data loader(dataset = train dt，batch_size=batchsiz，shuffle=True) 用于加载数据集。
import torch
from tqdm import tqdm
import torch.nn as nn
import torch.optim as optim
import torchvision.datasets as datasets
from torch.utils.data import DataLoader
from torchvision.transforms import transforms
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
inpsize = 30
seqlen = 30
numlayrs = 4
hidensize = 258
numclasses = 12
lr = 0.001
batchsiz = 66
numepchs = 4
class RNN(nn.Module):
def __init__(self, inpsize, hidensize, numlayrs, numclasses, seqlen):
super(RNN, self).__init__()
self.hidensize = hidensize
self.numlayrs = numlayrs
self.lstm = nn.LSTM(inpsize, hidensize, numlayrs, batch_first=True)
self.fc = nn.Linear(hidensize*seqlen, numclasses)
def forward(self, data):
h1 = torch.zeros(self.numlayers, data.size(0), self.hidensize).to(device)
c1 = torch.zeros(self.numlayers, data.size(0), self.hidensize).to(device)
outp, _ = self.lstm(data, (h1, c1))
outp = outp.reshape(outp.shape[0], -1)
outp = self.fc(outp)
return outp
traindt = datasets.MNIST(root='dataset/', train=True, transform=transforms.ToTensor(), download=True)
testdt = datasets.MNIST(root='dataset/', train=False, transform=transforms.ToTensor(), download=True)
trainldr = DataLoader(dataset=traindt, batch_size=batchsiz, shuffle=True)
testldr = DataLoader(dataset=testdt, batch_size=batchsiz, shuffle=True)
输出:
运行上述代码后，我们得到以下输出，从中我们可以看到 RNN 模型数据可以加载到屏幕上。
PyTorch RNN data loader
你可能也喜欢阅读下面的 PyTorch 教程。
因此，在本教程中，我们讨论了 PyTorch RNN ，并且我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch RNN
- PyTorch RNN 示例
- pytorch rnn 细胞
- PyTorch RNN 激活函数
- PyTorch RNN 二元分类法
- PyTorch RNN 情绪分析
- PyTorch RNN 语言模型
- pyzer rn 数据加载器
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch 保存模型–完整指南
在这个 Python 教程中，我们将学习如何在 Python 中保存 PyTorch 模型，我们还将涵盖与保存模型相关的不同示例。此外，我们将涵盖这些主题。
- PyTorch 保存模型
- PyTorch 保存模型示例
- PyTorch 保存模型检查点
- PyTorch 保存模型架构
- PyTorch 保存模型用于推理
- PyTorch 在培训期间保存模型
- PyTorch 将模型保存到 onnx
目录
- 指针保存模型
- PyTorch 保存模型示例
- PyTorch 保存模型检查点
- PyTorch 保存模型架构
- PyTorch 保存用于推理的模型
- PyTorch 在训练期间保存模型
- PyTorch 将模型保存到 onnx
指针保存模型
在这一节中，我们将学习如何在 Python 中保存 PyTorch 模型。
- PyTorch 保存模型用于保存多个组件，也用于在
torch.save()函数的帮助下序列化字典中的组件。 - 保存功能用于检查模型的连续性，即保存后模型是如何保存的。
代码:
在使用 Pytorch 保存模型功能之前，我们想通过下面的命令安装 torch 模块。
pip install torch
安装完手电筒模块后，还需要在此命令的帮助下安装触摸视觉模块。
pip install torchvision
PyTorch save model torchversion module
安装好所有东西后，PyTorch saves 模型的代码就可以顺利运行了。
torch model = model . vgg 16(pre trained = True)用于建立模型。- torch . save(torch model . state _ dict()，' torchmodel_weights.pth') 用于保存 PyTorch 模型。
state_dic()函数定义为 python 字典，将每一层映射到其参数张量。
import torch
import torchvision.models as model
torchmodel = model.vgg16(pretrained=True)
torch.save(torchmodel.state_dict(), 'torchmodel_weights.pth')
PyTorch save model path
另外，检查:使用 Python 的机器学习
PyTorch 保存模型示例
在这一节中，我们将学习如何保存 PyTorch 模型，并借助 Python 中的示例进行解释。
- PyTorch 保存功能用于保存多个组件，并将所有组件排列到一个字典中。
torch.save()函数用于将组件保存并排列到字典中。
代码:
在下面的代码中，我们将导入一些 torch 库，通过制作模型并在制作后保存它来训练分类器。
model = TheModelClass()用于初始化模型。- 优化器=优化。SGD(model.parameters()，lr=0.001，momentum=0.8) 用于初始化优化器。
- print("模型的 state_dict:") 用于打印 state_dict。
state_dict定义为 python 字典，将每一层映射到其参数张量。- print("优化器的 state_dict:") 用于打印优化器的 state_dict。
- torch.save(model.state_dict()，' model_weights.pth') 用于保存模型。
import torch
import torch.nn as nn
import torch.optim as optimize
**# Define model**
class TheModelClass(nn.Module):
def __init__(self):
super(TheModelClass, self).__init__()
self.conv = nn.Conv2d(4, 7, 6)
self.pool = nn.MaxPool2d(3, 3)
self.conv1 = nn.Conv2d(7, 17, 6)
self.fc1 = nn.Linear(17 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, X):
X = self.pool(F.relu(self.conv(X)))
X = self.pool(F.relu(self.conv1(X)))
X = X.view(-1, 17 * 5 * 5)
X = F.relu(self.fc1(X))
X = F.relu(self.fc2(X))
X = self.fc3(X)
return X_train_gray
model = TheModelClass()
optimizer = optimize.SGD(model.parameters(), lr=0.001, momentum=0.8)
print("Model's state_dict:")
for param_tensor in model.state_dict():
print(param_tensor, "\t", model.state_dict()[param_tensor].size())
print("Optimizer's state_dict:")
for var_name in optimizer.state_dict():
print(var_name, "\t", optimizer.state_dict()[var_name])
torch.save(model.state_dict(), 'model_weights.pth')
输出:
运行上述代码后，我们得到以下输出，从中可以看到我们可以训练一个分类器，并在训练后保存模型。
PyTorch save model
阅读: PyTorch nn 线性+例题
PyTorch 保存模型检查点
在本节中，我们将学习如何在 Python 中保存 PyTorch 模型检查点。
- PyTorch 保存模型检查点用于借助 torch.save()函数保存多个检查点。
- torch.save()函数也用于定期设置字典。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以保存模型检查点。
- nn。Conv2d() 用于定义从输入产生输出的神经网络。
- self.pool() 被定义为用于存储实例的类似字典的结构。
- 优化器=优化。SGD(net1.parameters()，lr=0.001，momentum=0.9) 用于初始化优化器。
torch.save()用于保存 PyTorch 模型。
import torch
import torch.nn as nn
import torch.optim as optimize
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv = nn.Conv2d(5, 8, 7)
self.pool = nn.MaxPool2d(4, 4)
self.conv1 = nn.Conv2d(8, 18, 7)
self.fc = nn.Linear(18 * 7 * 7, 140)
self.fc1 = nn.Linear(140, 86)
self.fc2 = nn.Linear(86, 12)
def forward(self, X):
X = self.pool(F.relu(self.conv(X)))
X = self.pool(F.relu(self.conv1(X)))
X = X.view(-1, 18 * 7 * 7)
X = F.relu(self.fc(X))
X = F.relu(self.fc1(X))
X = self.fc2(x)
return X
net1 = Net()
print(net1)
optimizer = optimize.SGD(net1.parameters(), lr=0.001, momentum=0.9)
EPOCH = 5
PATH = "model.pt"
LOSS = 0.4
torch.save({
'epoch': EPOCH,
'model_state_dict': net1.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'loss': LOSS,
}, PATH)
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到，在使用 save() 函数保存检查点模型后，多个检查点被打印在屏幕上。
PyTorch save model checkpoint
PyTorch 保存模型架构
在这一节中，我们将学习如何在 python 中保存 PyTorch 模型架构。
Pytorch 保存模型建筑被定义为设计一个结构在其他我们可以说是建造一个建筑。
代码:
在下面的代码中，我们将导入一些有助于运行代码和保存模型的库。
use _ cuda = torch . cuda . is _ available()用于 CUDA 张量类型，available()函数用于确定 CUDA 是否支持我们的系统。- torch.save(state，fpath) 用于保存模型。
- shutil.copyfile(fpath，bestfpath) 用于将文件复制到给定的最佳部分。
import matplotlib.pyplot as plot
import torch
import shutil
from torch import nn
from torch import optim
import torch.nn.functional as F
from torchvision import datasets, transforms
import numpy as num
use_cuda = torch.cuda.is_available()
def savemodel(state, is_best, checkpointpath, bestmodel_path):
fpath = checkpointpath
torch.save(state, fpath)
**# if it is a best model, min validation loss**
if is_best:
bestfpath = bestmodel_path
shutil.copyfile(fpath, bestfpath)
保存模型后，我们可以加载模型以检查最佳拟合模型。
model check point = torch . load(check point fpath)用于加载检查点。- model . load _ state_dict(model check point[' state _ dict '])用于初始化从检查点到模型的 state _ dict。
- optimizer . load _ state _ dict(model check point[' optimizer '])用于初始化优化器。
- valid_loss_min = model check point[' valid _ loss _ min ']用于从检查点初始化 valid _ loss _ min。
- 返回模型，优化器，模型检查点['epoch']，valid_loss_min.item() 用于返回模型。
def load_model(checkpointfpath, model, optimizer):
modelcheckpoint = torch.load(checkpointfpath)
model.load_state_dict(modelcheckpoint['state_dict'])
optimizer.load_state_dict(modelcheckpoint['optimizer'])
valid_loss_min = modelcheckpoint['valid_loss_min']
return model, optimizer, modelcheckpoint['epoch'], valid_loss_min.item()
加载模型后，我们希望导入数据并创建数据加载器。
- 转换数据=转换。撰写([转换。ToTensor()，转换。Normalize((0.5，0.5，0.5)，(0.5，0.5)，0.5))]) 用于定义一个转换来规范化数据。
- 训练集=数据集。fashion mnist(' F _ MNIST _ 数据/'，download=True，train=True，transform=transformdata) 用于下载加载训练数据。
- loaders = { ' train ':torch . utils . data . data loader(trainset，batch_size = 64，shuffle=True)，' test ':torch . utils . data . data loader(testset，batch_size = 64，shuffle=True)，} 用于加载数据加载器。
transformdata = transforms.Compose([transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
# Download and load the training data
train_set = datasets.FashionMNIST('F_MNIST_data/', download=True, train=True, transform=transformdata)
test_set = datasets.FashionMNIST('F_MNIST_data/', download=True, train=False, transform=transformdata)
loaders = {
'train' : torch.utils.data.DataLoader(trainset,batch_size = 64,shuffle=True),
'test' : torch.utils.data.DataLoader(testset,batch_size = 64,shuffle=True),
}
在下面的代码中，我们将定义函数并创建模型的架构。
model = fashion _ Classifier()用于创建网络和定义优化器。model.cuda()当 cuda 可以将模型移动到 GPU 时使用。
**# Define your network**
class fashion_Classifier(nn.Module):
def __init__(self):
super().__init__()
input_size = 784
self.fc = nn.Linear(input_size, 514)
self.fc1 = nn.Linear(514, 258)
self.fc2 = nn.Linear(258, 130)
self.fc3 = nn.Linear(130, 66)
self.fc4 = nn.Linear(66,12)
self.dropout = nn.Dropout(p=0.2)
def forward(self, X):
X = X.view(X.shape[0], -1)
X = self.dropout(F.relu(self.fc1(X)))
X = self.dropout(F.relu(self.fc2(X)))
X = self.dropout(F.relu(self.fc3(X)))
X = self.dropout(F.relu(self.fc4(X)))
X = F.log_softmax(self.fc5(X), dim=1)
return X_train_prepared
model = fashion_Classifier()
if use_cuda:
model = model.cuda()
print(model)
PyTorch save model architecture
PyTorch 保存用于推理的模型
在这一节中，我们将学习 python 中的 PyTorch 保存推理模型。
- PyTorch 将推理模型定义为得出证据和推理的结论。
- 火炬。Save() 函数用于保存模型并在字典中排列组件。
代码:
在下面的代码中，我们将导入一些库，从中我们可以保存模型推理。
- 优化器=优化。SGD(net.parameters()，lr=0.001，momentum=0.9) 用于初始化优化器。
PATH = " state _ dict _ model . pt "用于指定路径。- torch.save(net.state_dict()，PATH) 用于保存模型。
models . load _ state _ dict(torch . load(PATH))用于加载模型。PATH = "entire_model.pt"用于指定路径。
import torch
import torch.nn as nn
import torch.optim as optimizer
import torch.nn.functional as f
class model(nn.Module):
def __init__(self):
super(model, self).__init__()
self.conv = nn.Conv2d(5, 8, 7)
self.pool = nn.MaxPool2d(4, 4)
self.conv1 = nn.Conv2d(8, 18, 7)
self.fc = nn.Linear(18 * 7 * 7, 140)
self.fc1 = nn.Linear(140, 86)
self.fc2 = nn.Linear(86, 12)
def forward(self, X):
X = self.pool(f.relu(self.conv(X)))
X = self.pool(f.relu(self.conv1(X)))
X = X.view(-3, 17 * 7 * 7)
X = f.relu(self.fc(X))
X = f.relu(self.fc1(X))
X = self.fc2(X)
return X
net = model()
print(net)
optimizer = optimize.SGD(net.parameters(), lr=0.001, momentum=0.9)
PATH = "state_dict_model.pt"
torch.save(net.state_dict(), PATH)
models = model()
models.load_state_dict(torch.load(PATH))
models.eval()
PATH = "entire_model.pt"
torch.save(net, PATH)
models = torch.load(PATH)
models.eval()
输出:
运行上面的代码后，我们得到了下面的输出，从中我们可以看到模型的推断。
PyTorch save the model for inference
阅读: PyTorch 负载模型+示例
PyTorch 在训练期间保存模型
在本节中，我们将学习如何在 python 中训练期间保存 PyTorch 模型。
PyTorch 模型在训练期间借助 torch.save() 函数进行保存。保存函数后，我们可以加载模型并训练模型。
代码:
在下面的代码中，我们将导入一些用于训练模型的库。在训练过程中，我们可以保存模型。
- torch.save(Cnn，PATH) 用于保存模型。
- bs，，，_ = X.shape 用于获取批量。
- X = f.adaptive_avg_pool2d(X，1)。reshape(bs，-1) 用于重塑模型。
- traindata =数据集。CIFAR10() 用于训练模型。
- valdata =数据集。CIFAR10() 用于验证数据。
import torch.nn as nn
import torch.nn.functional as f
**# model**
class Cnn(nn.Module):
def __init__(self):
super(Cnn, self).__init__()
self.conv = nn.Conv2d(in_channels=5, out_channels=66, kernel_size=7, padding=1)
self.conv1 = nn.Conv2d(in_channels=66, out_channels=66, kernel_size=7, padding=1)
self.conv2 = nn.Conv2d(in_channels=66, out_channels=130, kernel_size=7, padding=1)
self.pool = nn.MaxPool2d(5, 4)
self.dropout = nn.Dropout2d(0.7)
self.fc = nn.Linear(in_features=130, out_features=1000)
self.fc1 = nn.Linear(in_features=1000, out_features=10)
def forward(self, X):
X = f.relu(self.conv1(X))
X = self.dropout(X)
X = self.pool(X)
X = f.relu(self.conv2(X))
x = self.pool(X)
x = f.relu(self.conv3(X))
x = self.pool(X)
bs, _, _, _ = X.shape
X = f.adaptive_avg_pool2d(X, 1).reshape(bs, -1)
X = F.relu(self.fc1(X))
X = self.dropout(X)
out = self.fc2(X)
return out
torch.save(Cnn,PATH)
from torchvision import datasets
from torchvision.transforms import transforms
**# define transforms**
transformtrain = transforms.Compose([
transforms.RandomCrop(34, padding=6),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4916, 0.4824, 0.4467),
(0.2025, 0.1996, 0.2012)),
])
transformval = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4916, 0.4824, 0.4467),
(0.2025, 0.1996, 0.2012)),
])
**# train and validation data**
traindata = datasets.CIFAR10(
root='../input/data',
train=True,
download=True,
transform=transformtrain
)
valdata = datasets.CIFAR10(
root='../input/data',
train=False,
download=True,
transform=transformval
)
输出:
运行上面的代码后，我们得到下面的输出，我们可以看到屏幕上正在下载训练数据。
PyTorch save model during training
阅读: PyTorch 预训练模型
PyTorch 将模型保存到 onnx
在本节中，我们将了解 PyTorch 如何用 Python 将模型保存到 onnx 中。
- ONNX 被定义为一个开放的神经网络交换，它也被称为神经网络交换的开放容器格式。
- 在这里，我们将模型转换成 ONNX 格式，并使用 ONNX 运行时运行该模型。
代码:
在下面的代码中，我们将导入一些库，从这些库中我们可以将模型保存到 onnx。
torch _ model = SuperResolutionmodel(upscale _ factor = 3)用于创建超分辨率模型。- modelurl = ' https://S3 . amazonaws . com/py torch/test _ data/export/super RES _ epoch 100-44c 6958 e . PTH '用于加载模型重量。
- torch _ model . load _ state _ dict(model zoo . load _ URL(model URL，map_location=maplocation)) 用于用相关权重初始化模型。
torch_model.eval()用于设置模型。
import io
import numpy as num
from torch import nn
import torch.utils.model_zoo as modelzoo
import torch.onnx
import torch.nn as nn
import torch.nn.init as init
class SuperResolutionmodel(nn.Module):
def __init__(self, upscale_factor, inplace=False):
super(SuperResolutionmodel, self).__init__()
self.relu = nn.ReLU(inplace=inplace)
self.conv1 = nn.Conv2d(1, 64, (5, 5), (1, 1), (2, 2))
self.conv2 = nn.Conv2d(64, 64, (3, 3), (1, 1), (1, 1))
self.conv3 = nn.Conv2d(64, 32, (3, 3), (1, 1), (1, 1))
self.conv4 = nn.Conv2d(32, upscale_factor ** 2, (3, 3), (1, 1), (1, 1))
self.pixel_shuffle = nn.PixelShuffle(upscale_factor)
self._initialize_weights()
def forward(self, X):
X = self.relu(self.conv1(X))
X = self.relu(self.conv2(X))
X = self.relu(self.conv3(X))
X = self.pixel_shuffle(self.conv4(X))
return X
def _initialize_weights(self):
init.orthogonal_(self.conv1.weight, init.calculate_gain('relu'))
init.orthogonal_(self.conv2.weight, init.calculate_gain('relu'))
init.orthogonal_(self.conv3.weight, init.calculate_gain('relu'))
init.orthogonal_(self.conv4.weight)
torch_model = SuperResolutionmodel(upscale_factor=3)
modelurl = 'https://s3.amazonaws.com/pytorch/test_data/export/superres_epoch100-44c6958e.pth'
batch_size = 1
maplocation = lambda storage, loc: storage
if torch.cuda.is_available():
map_location = None
torch_model.load_state_dict(modelzoo.load_url(modelurl, map_location=maplocation))
torch_model.eval()
PyTorch save the model to ONNX
- X = torch.randn(batch_size，1，224，224，requires_grad=True) 用作模型的输入。
torch.onnx.export()用于导出模型。- ort inputs = { ort _ session . get _ inputs()[0]。name: to_numpy(x)} 用于计算 onnx 运行时的输出预测。
- print("导出模型用 ONNXRuntime 测试，模型的结果看起来不错！")用于打印模型结果。
X = torch.randn(batch_size, 1, 224, 224, requires_grad=True)
torch_out = torch_model(x)
torch.onnx.export(torch_model,
x,
"super_resolution.onnx",
export_params=True,
opset_version=10,
do_constant_folding=True,
input_names = ['input'],
output_names = ['output'],
dynamic_axes={'input' : {0 : 'batch_size'},
'output' : {0 : 'batch_size'}})
import onnx
onnxmodel = onnx.load("super_resolution.onnx")
onnx.checker.check_model(onnxmodel)
import onnxruntime
ortsession = onnxruntime.InferenceSession("super_resolution.onnx")
def to_numpy(tensor):
return tensor.detach().cpu().numpy() if tensor.requires_grad else tensor.cpu().numpy()
ortinputs = {ort_session.get_inputs()[0].name: to_numpy(x)}
ortoutputs = ort_session.run(None, ortinputs)
**# compare ONNX Runtime and PyTorch results**
num.testing.assert_allclose(to_numpy(torch_out), ortoutputs[0], rtol=1e-03, atol=1e-05)
print("Export model is tested with ONNXRuntime, and the result of the model looks good!")
PyTorch save model tested with ONNX runtime
因此，在本教程中，我们讨论了 PyTorch 保存模型,我们还讨论了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch 保存模型
- PyTorch 保存模型示例
- PyTorch 保存模型检查点
- PyTorch 保存模型架构
- PyTorch 保存模型用于推理
- PyTorch 在培训期间保存模型
- PyTorch 将模型保存到 onnx
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
py torch soft max[完整教程]
PyTorch Softmax 是一个应用于 n 维输入张量并对其进行重新缩放的函数，n 维输出张量的元素位于范围[0，1]内。详细来说，我们将讨论在 Python 中使用 PyTorch 的 Softmax。
此外，我们还将介绍与 PyTorch softmax 相关的不同示例。我们将讨论这些话题。
- 什么是 PyTorch softmax
- PyTorch softmax 示例
- 如何使用 PyTorch softmax 激活功能
- PyTorch 函数 softmax
- PyTorch softmax 维度
- 什么是 PyTorch softmax2d
- PyTorch softmax 交叉熵
- 什么是 PyTorch Logsoftmax
目录
- 什么是 PyTorch softmax
- PyTorch softmax 示例
- 如何使用 PyTorch softmax 激活功能
- PyTorch 功能 softmax
- PyTorch softmax 尺寸
- 什么是 PyTorch softmax2d
- PyTorch softmax 交叉熵
- 什么是 Pytorch Logsoftmax
什么是 PyTorch softmax
在本节中，我们将学习 python 中的 PyTorch softmax 。
PyTorch softmax 应用于 n 维输入张量并对其进行重新缩放，使得 n 维张量的输出张量位于范围[0，1]内。
语法:
softmax 张量的语法是:
torch.nn.Softmax(dim=None)
参数:
以下是 PyTorch softmax 的参数:
dim: dim 与 softmax 一起作为一个维度被计算，dim 上的每个块将被加和为一。
softmax 以输入的形式返回一个具有相同维度和形状的张量，其值在[0，1]范围内。
这样，我们通过使用 softmax()函数了解了 PyTorch softmax。
PyTorch softmax 示例
在本节中，我们将借助一个例子来了解如何实现 Pytorch softmax 。
softmax()函数应用于 n 维输入张量并对其进行重新缩放。softmax()可以通过使用 nn.softmax()函数来执行。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch 和 import torch.nn as nn。
- a = nn。Softmax(dim=1): 这里我们使用的是 Softmax()函数。
- input = torch.randn(4，5): 这里我们用 torch.randn()函数声明输入变量。
- 打印(输出)用于使用 print()函数打印输出。
# Importing Libraries
import torch
import torch.nn as nn
# Using Softmax() function
a = nn.Softmax(dim=1)
# Describing a variable
input = torch.randn(4, 5)
# Declaring the output
output = a(input)
# Print the output
print(output)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch softmax 值打印在屏幕上。
PyTorch softmax example
这就是我们如何在一个例子的帮助下实现 PyTorch softmax 函数。
读取 PyTorch 保存模型
如何使用 PyTorch softmax 激活功能
在本节中，我们将学习 python 中的 PyTorch softmax 激活函数。
在继续之前，我们应该有一个关于激活函数的知识。
激活函数是执行计算以给出输出的函数，该输出充当下一个神经元的输入。
代码:
在下面的代码中，我们将首先导入所有必要的库，如 import torch，import torch.nn as nn。
- b = nn。Softmax(dim=0) 用作 Softmax 函数，dim=0，因为尺寸从 0 开始。
- 输入=火炬。张量([3，-4，5，-7]) 用来声明张量。
output = b(input)用于对张量应用函数。- 打印(输出)用于借助 print()函数打印输出。
# Importing libraries
import torch
import torch.nn as nn
# Using the Softmax function with dim = 0 as dimension starts from 0
b = nn.Softmax(dim=0)
# Declaring the tensor
input = torch.Tensor([3,-4,5,-7])
# Applying function to the tensor
output = b(input)
# Print the output
print(output)
输出:
在下面的输出中，我们可以看到 PyTorch softmax 激活函数值打印在屏幕上。
PyTorch softmax activation function
至此，我们了解了 python 中的 Pytorch softmax 激活函数。
PyTorch 功能 softmax
在本节中，我们将学习 python 中的 PyTorch 函数 softmax 。
PyTorch functional softmax 与 dim 一起应用于所有块，并重新缩放它们，以便元素位于范围[0，1]内。
语法:
PyTorch 函数 softmax 的语法:
torch.nn.functional.softmax(input, dim=None, dtype=None)
参数:
以下是 PyTorch functional softmax 的参数:
- 输入:输入参数定义为输入张量。
- dim:dim 参数被定义为一个与 softmax 一起计算的尺寸。
- dtype: 定义为返回张量的所需数据类型，用于防止数据类型溢出，dtype 的默认值为 None。
这就是我们如何通过使用 torch.nn.functional.Softmax()来理解 PyTorch 泛函 softmax。
PyTorch softmax 尺寸
在本节中，我们将学习 python 中的 PyTorch softmax 维度。
在前进之前，我们应该有一个关于维度的知识。
维度被定义为特定种类的可量化的增加，如长度、高度、宽度和深度。
尺寸是一个参数，它与将被计算的 softmax 一起被定义为 dim。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch，import nn from torch。
- m = nn。Softmax(dim=1): 这里我们使用的是 Softmax()函数。
- input = torch.tensor([[5.0，6.0，3.0]]，dtype=torch.float) 用于通过 torch.tensor()函数声明输入变量。
output = m(input)用于声明输出变量。- 打印(输出)用于借助 print()函数打印输出。
# Importing Libarray
import torch
from torch import nn
# Using the Softmax() function
m = nn.Softmax(dim=1)
# Declaring the input variable
input = torch.tensor([[5.0, 6.0, 3.0]],dtype=torch.float)
# Declaring the output variable
output = m(input)
# Print output
print(output)
输出:
在下面的输出中，您可以看到 Pytorch softmax 尺寸值打印在屏幕上。
PyTorch softmax dimension
这样，我们通过使用 nn.softmax()函数了解了 PyTorch softmax 维度。
什么是 PyTorch softmax2d
在本节中，我们将了解 python 中的 PyTorch softmax2d 是什么。
PyTorch Softmax2d 是一个将 Softmax 应用于每个概念位置的类。
语法:
torch.nn.softmax2d()
它返回与输入具有相同维数和形状的张量，其值在[0，1]范围内。
举例:
在下面的代码中，我们将导入火炬库作为导入火炬。
- m = nn。Softmax2d(): 这里我们使用的是 Softmax2d()。
- input = torch.randn(4，5，14，15): 这里我们声明的是第二维上的 softmax。
- output = m(input): 这里我们描述的是输出变量。
- 打印(输出)用于使用 print()函数打印输出。
# Import library
import torch
# Using softmax2d
m = nn.Softmax2d()
# softmax over the 2nd dimension
input = torch.randn(4, 5, 14, 15)
#Declaring the output variable
output = m(input)
#Print output
print(output)
输出:
在下面的输出中，您可以看到 PyTorch Softmax2d 值打印在屏幕上。
这就是我们借助 softmax2d()函数理解 PyTorch softmax2d 的方法。
PyTorch softmax 交叉熵
在本节中，我们将学习 python 中的 PyTorch softmax 交叉熵。
torch.nn.CrossEntropyLoss()类计算输入和目标之间的交叉熵损失，softmax()函数用于根据类概率确定目标。
代码:
在下面的代码中，我们将首先导入 torch 库，如 import torch。
- 损失= nn。CrossEntropyLoss(): 这里我们使用的是 CrossEntropyLoss()函数。
- input = torch.randn(5，7，requires_grad=True) 用于声明输入变量。
- target = torch.randn(5，7)。softmax(dim=1): 这里我们声明目标变量。
- 输出=损失(输入，目标):这里我们描述的是输出变量。
- 打印(输出)用于借助 print()函数打印输出。
# Import library
import torch
loss = nn.CrossEntropyLoss()
# Declaring the input variable
input = torch.randn(5, 7, requires_grad=True)
#Decaring the target variable
target = torch.randn(5, 7).softmax(dim=1)
# Describing the output variable
output = loss(input, target)
output.backward()
# Print output
print(output)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch softmax 交叉熵值打印在屏幕上。
PyTorch softmax cross entropy
这样，我们理解了 python 中 PyTorch softmax 交叉熵。
读取 PyTorch 负载模型
什么是 Pytorch Logsoftmax
在本节中，我们将学习 python 中的 PyTorch Logsoftmax 。
PyTorch Logsoftmax 将 Logsoftmax()函数应用于 n 维输入张量。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch，import torch.nn as nn。
- input = torch.rand(4，5): 这里我们用 torch.rand()函数声明输入变量。
- a = nn。Softmax(dim=1): 这里我们使用的是 Softmax()函数。
- a = nn。LogSoftmax(dim=1) 这里我们声明 LogSoftmax()函数。
# Importing libraries
import torch
import torch.nn as nn
# Declaring the variable
input = torch.rand(4,5)
# Using the softmax
a = nn.Softmax(dim=1)
soft = a(input)
print(soft)
soft = torch.softmax(input, dim=1)
print(soft)
# Declaring the Logsoftmax() function
input = torch.randn(4,5,6)
a = nn.LogSoftmax(dim=1)
output = m(input)
# print the output
print(output)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch Logsoftmax 值打印在屏幕上。
PyTorch Logsoftmax
这就是我们借助 python 中的 Logsigmoid()函数对 PyTorch Logsoftmax 的理解。
因此，在本教程中，我们将讨论 PyTorch Softmax ,并且我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- 什么是 PyTorch softmax
- PyTorch softmax 示例
- 如何使用 PyTorch softmax 激活功能
- PyTorch 函数 softmax
- PyTorch softmax 维度
- 什么是 PyTorch softmax2d
- PyTorch softmax 交叉熵
- 什么是 PyTorch Logsoftmax
您可能会喜欢以下 PyTorch 教程:
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch 堆栈教程+示例
*py torch torch . stack()*函数用于连接具有相同维度和形状的张量。详细来说，我们将讨论 Python 中使用 PyTorch 的 stack() 函数。
此外，我们将介绍与 PyTorch 堆栈函数相关的不同示例。我们将讨论这些话题。
- 什么是 PyTorch 堆栈
- PyTorch 堆栈示例
- 如何使用 Pytorch 堆栈张量
- PyTorch 2d 张量将被叠加以创建 3d 张量
- PyTorch 1d 张量堆叠并生成 2d 张量作为最终张量
- PyTorch 堆栈显示输入张量形状不同时的错误
目录
- 什么是 PyTorch 堆栈
- PyTorch 堆栈示例
- 如何使用 Pytorch 堆栈张量
- PyTorch 2d 张量被叠加以创建 3d 张量
- PyTorch 堆叠 1d 张量并生成 2d 张量作为最终张量
- PyTorch 堆栈显示输入张量形状不同时的错误
什么是 PyTorch 堆栈
在本节中，我们将学习 python 中的 PyTorch 堆栈。
*PyTorch stack()* 方法用于将一系列张量与一个新维度连接或串联。该函数用于连接具有相同维度和形状的张量。
语法:
PyTorch 堆栈的语法:
torch.stack(tensors, dim=0, out=None)
参数:
以下是 PyTorch 堆栈的参数:
- 张量:张量被定义为一系列具有新维度的张量。
- dim:dim 是要插入的维数，其整数介于 0 和输入张量的维数之间。
- out:out 是描述输出张量的参数。
这就是我们借助 torch.stack()函数理解 Pytorch 堆栈的方式。
PyTorch 堆栈示例
在这一节中，我们将借助 python 中的一个例子来学习如何实现 PyTorch 堆栈。
torch.stack() 方法，其中所有张量需要具有相同的大小，并用于将一系列张量与一个新维度结合或连接。
代码:
在下面的代码中，我们将导入 torch 模块，如 import torch。
- stackt1 = torch.tensor([1。,3.,6.,10.]): 这里我们使用 torch.tensor()函数创建一个张量。
- print("Tensor stackt1:"，stackt1) 用于打印使用 print()函数创建的张量。
- s = torch.stack((stackt1，stackt2)): 这里我们调用的是 stack()函数。
- print(s): 这里我们借助 print()函数打印连接后的最终张量。
# importing torch
import torch
# Creating a tensors
stackt1 = torch.tensor([1.,3.,6.,10.])
stackt2 = torch.tensor([2.,7.,9.,13.])
# printing above created tensors
print("Tensor stackt1:", stackt1)
print("Tensor ystackt2:", stackt2)
# join above tensor using "torch.stack()"
print("Join the tensors:")
s = torch.stack((stackt1,stackt2))
# print final tensor after join
print(s)
print("Join the tensors dimension 0:")
s = torch.stack((stackt1,stackt2), dim = 0)
print(s)
print("join tensors dimension 1:")
s = torch.stack((stackt1,stackt2), dim = 1)
print(s)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 堆栈值被打印在屏幕上。
PyTorch stack example
至此，我们借助 python 中的一个例子理解了 PyTorch 堆栈。
如何使用 Pytorch 堆栈张量
在本节中，我们将学习 python 中的 PyTorch 堆栈张量。
PyTorch 堆栈张量被定义为沿着新的维度连接两个或更多个张量的序列的方法。
代码:
在下面的代码中，我们将导入火炬库作为导入火炬。
- stacktensor_1 =火炬。张量([[20，30，40]，[50，60，70]]): 这里我们用 torch.tensor()函数来描述变量。
- print("stacktensor_1 \n "，stacktensor_1) 用于使用 print()函数打印第一个张量。
- stack tensor = torch.stack((stack tensor _ 1，stacktensor_2)，-1): 这里我们调用的是 torch . stack()函数。
- print(" Join tensor in-1 dimension \ n "，stacktensor) 用于通过 print()函数打印堆栈张量值。
# import torch library
import torch
# define tensors
stacktensor_1 = torch.Tensor([[20,30,40],[50,60,70]])
stacktensor_2 = torch.Tensor([[40,50,60],[70,80,90]])
# print first tensors
print("stacktensor_1 \n", stacktensor_1)
# print second tensor
print("stacktensor_2 \n", stacktensor_2)
# Calling the torch.stack() function join tensor in -1 dimension
stacktensor = torch.stack((stacktensor_1, stacktensor_2), -1)
print("Join the tensors in the -1 dimension \n", stacktensor)
# Join the tensor in 0 dimension
stacktensor = torch.stack((stacktensor_1, stacktensor_2), 0)
print("Join the tensors in the 0 dimension \n", stacktensor)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 堆栈张量值打印在屏幕上。
PyTorch stack tensor
这就是我们如何通过使用 torch.stack()函数来理解 PyTorch 堆栈张量。
PyTorch 2d 张量被叠加以创建 3d 张量
在这一节中，我们将学习 PyTorch 2d 张量如何在 python 中创建 3d 张量。
这里我们用的是二维张量，我们把所有的张量连接在一起，创建了三维张量。
代码:
在下面的代码中，我们将导入 torch 库，如 import torch。
- stacktens1 =火炬。张量([[2，4]，[4，8]]): 这里我们用 torch.tensor()函数声明变量。
- print("\n 栈首张量:\n "，stacktens1) 用于通过 print()函数打印栈首张量。
- stack tens = torch . stack((stack tens 1，stacktens2，stacktens3)，-1): 这里我们是-1 维的堆叠张量。
- print(" \n-1 维张量\ n "，stacktens) 用于借助 print()函数打印-1 维张量。
- stack tens = torch . stack((stack tens 1，stacktens2，stacktens3)，0): 这里我们把 0 维的张量堆叠起来。
# import library
import torch
# declaring some tensors
stacktens1 = torch.Tensor([[2, 4], [4, 8]])
stacktens2 = torch.Tensor([[3, 4], [5, 10]])
stacktens3 = torch.Tensor([[8, 16], [9, 18]])
# Display the tensors
print("\n Stack First Tensor :\n", stacktens1)
print("\n Stack Second Tensor :\n", stacktens2)
print("\n Stack Third Tensor :\n", stacktens3)
# stacked tensors in -1 dimension
stacktens = torch.stack((stacktens1, stacktens2, stacktens3), -1)
print("\n tensors in -1 dimension \n", stacktens)
# stacked tensors in 0 dimension
stacktens = torch.stack((stacktens1, stacktens2, stacktens3), 0)
print("\n tensors in 0 dimension \n", stacktens)
输出:
在下面的输出中，您可以看到 PyTorch 2d 张量将被堆叠以创建打印在屏幕上的 3d 张量值。
PyTorch 2d tensor to be stack to create 3d tensor
这样，我们就了解了 PyTorch 二维张量是如何叠加起来产生三维张量的。
阅读: PyTorch 添加尺寸
PyTorch 堆叠 1d 张量并生成 2d 张量作为最终张量
在本节中，我们将学习 PyTorch 1d 张量堆栈，并生成一个 2d 张量作为 python 中的最终张量。
这里我们使用 torch.stack()函数从 PyTorch 一维张量生成二维张量作为最终张量。
代码:
在下面的代码中，我们将导入所需的库，如 import torch。
- stacktens1 =火炬。张量([2，4，6]): 这里我们用 torch.tensor()函数来定义张量。
- print("栈首张量:\n "，stacktens1) 用于借助 print()函数打印栈首张量。
- stack tens = torch . stack((stack tens 1，stacktens2，stacktens3)，0): 这里我们调用的是 stack()函数。
# import required library
import torch
# Define some tensors
stacktens1 = torch.Tensor([2, 4, 6])
stacktens2 = torch.Tensor([3, 6, 9])
stacktens3 = torch.Tensor([4, 8, 12])
# Display the tensors
print(" Stack First Tensor :\n", stacktens1)
print("\nStack Second Tensor :\n", stacktens2)
print("\n Stack Third Tensor :\n", stacktens3)
# Stack the tensors in the 0 dimension
stacktens = torch.stack((stacktens1, stacktens2, stacktens3), 0)
print("\n Join the tensors in the 0 dimension \n", stacktens)
# Stack the tensors in the -1 dimension
stacktens = torch.stack((stacktens1, stacktens2, stacktens3), -1)
print("\n Join the tensors in the -1 dimension \n", stacktens)
参数:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 1d 张量被堆叠并生成一个 2d 张量作为最终张量，值被打印在屏幕上。
PyTorch 1d tensor stacked and generate 2d tensor as final tensor
这就是我们如何理解 PyTorch 1d 张量如何堆叠并生成 2d 张量作为最终张量。
PyTorch 堆栈显示输入张量形状不同时的错误
在本节中，我们将了解 PyTorch 堆栈，当 python 中的输入张量形状不同时，它会显示错误。
这里我们使用 PyTorch 堆栈，它可以显示输入张量没有类似形状时的误差。
代码:
在下面的代码中，我们将导入必要的库，如 import torch。
- stacktens1 = torch.tensor([1。, 3., 6., 10.]): 这里我们使用 torch.tensor()函数创建堆栈张量。
- print("Tensor stacktens:"，stacktens1) 用于通过 print()函数打印张量堆栈。
- s = torch.stack((stacktens1，stacktens2)): 这里我们调用的是 stack()函数。
# importing torch
import torch
# Creating the stack tensors
stacktens1 = torch.tensor([1., 3., 6., 10.])
stacktens2 = torch.tensor([2., 7., 9.])
# Printing the tensors
print("Tensor stacktens:", stacktens1)
print("Tensor stac:", stacktens2)
# Stack the tensor using "torch.stack()"
print("Stack the tensors:")
s = torch.stack((stacktens1, stacktens2))
# Print the final tensor after join
print(s)
print("Stack the tensors dimension 0:")
s = torch.stack((stacktens1, stacktens2), dim=0)
print(s)
print("Stack the tensors dimension 1:")
s = torch.stack((stacktens1, stacktens2), dim=1)
print(s)
输出:
运行上面的代码后，我们得到了下面的输出，其中我们可以看到，当输入张量的形状不同时，会显示错误。
PyTorch stack to show error when the input tensor are not of the same shape
这就是我们理解 Pytorch 堆栈在输入张量形状不同时如何显示误差的方式。
另外，再看看一些 PyTorch 教程。
因此，在本教程中，我们讨论了 PyTorch 栈 ，我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch 栈是什么？
- PyTorch 堆栈示例
- 如何使用 Pytorch 堆栈张量
- PyTorch 2d 张量将被叠加以创建 3d 张量
- PyTorch 1d 张量堆叠并生成 2d 张量作为最终张量
- PyTorch 堆栈显示输入张量形状不同时的错误
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch TanH
PyTorch TanH 被定义为不同的非线性函数，与 sigmoid 函数相同，输出值在-1 到+1 的范围内。详细来说，我们将在 Python 中使用 PyTorch 来讨论 TahnH。
此外，我们还将涵盖与 PyTorch TanH 相关的不同示例。我们将讨论这些话题。
- 什么是 PyTorch TanH
- PyTorch TanH 示例
- PyTorch TanH inplace
- PyTorch TanH 激活函数
- 塔赫纳层
- PyTorch TanH 逆
- 什么是 PyTorch Tanhshrink
- 如何使用 PyTorch 功能性 TanH
- 皮托奇·塔恩 vs·里尔
目录
- 什么是 PyTorch TanH
- PyTorch TanH 示例
- PyTorch TanH inplace
- PyTorch TanH 激活功能
- 串层指针
- PyTorch TanH 逆
- 什么是 PyTorch Tanhshrink
- 如何使用 PyTorch functional TanH
- PyTorch TanH Vs ReLU
什么是 PyTorch TanH
在这一节中，我们将学习 python 中的 PyTorch TanH 。
PyTorch 双曲正切函数被定义为不同的非线性函数，与 sigmoid 函数相同，输出值在-1 到+1 的范围内。它是一条穿过原点的 S 形曲线。
语法:
PyTorch Tanh 的语法:
torch.nn.Tanh()
Tanh 按元素返回双曲正切函数。
这就是我们借助 torch.nn.Tanh()函数对 PyTorch TanH 的理解。
阅读 PyTorch 整形张量
PyTorch TanH 示例
在这一节中，我们将借助 python 中的一个例子学习如何实现 PyTorch TanH 。
Tanh 函数类似于 sigmoid 函数。这是一条 S 形曲线，但它穿过原点，Tanh 的输出值范围是从-1 到+1。双曲正切也是一个非线性和可微的函数。
代码:
在下面的代码中，首先我们导入所有必要的库，如 import torch，import torch.nn as nn。
- a = nn。Tanh(): 这里我们使用的是 Tanh()函数。
input = torch.randn(4)用于通过使用 torch.randn()函数来描述输入变量。output = a(input)用于声明输出变量。- 打印(输出)用于使用 print()函数打印输出。
# import library
import torch
import torch.nn as nn
# Using Tanh() function
a = nn.Tanh()
# Describing the input variable
input = torch.randn(4)
# Declaring the output variable
output = a(input)
# Print output
print(output)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch tanh 值打印在屏幕上。
PyTorch TanH example
至此，我们借助一个例子理解了 PyTorch TanH 的实现。
读取 PyTorch 添加尺寸
PyTorch TanH inplace
在这一节中，我们将借助 python 中的一个例子来了解 Pytorch TanH inplace 。
TanH 是激活函数的良好特性。它是非线性和可微分的，其输出范围在-1 到+1 之间。
语法:
PyTorch Tanh inplace 的语法:
nn.Tanh(inplace=True)
参数:
以下是 PyTorch Tanh inplace 的参数:
inplace = True 这意味着它将直接改变输入，而不分配任何额外的输出，inplace 的默认值为 False。
这样，我们在 nn 的帮助下了解了 PyTorch TanH。Tanh()函数。
PyTorch TanH 激活功能
在本节中，我们将学习 python 中的 Pytorch TanH 激活函数。
在继续之前，我们应该有一个关于激活函数的知识。
激活函数被定义为执行计算以给出输出的函数，该输出充当下一个神经元的输入。
双曲正切是一条穿过原点的 S 形曲线，输出值范围在-1 到+1 之间。
代码:
在下面的代码中，我们将导入库，如 import torch，import torch.nn as nn。
- th = nn。Tanh(): 这里我们使用的是 Tanh 函数。
- 输入=火炬。张量([2，-4，5，-7]) 用于通过使用 torch.tensor()函数来声明输入变量。
- output = th(input): 这里我们将双曲正切应用于张量。
- 打印(输出)用于借助 print()函数打印输出。
# Importing libraries
import torch
import torch.nn as nn
# Here we are calling the Tanh function
th = nn.Tanh()
# Declaring the tensor
input = torch.Tensor([2,-4,5,-7])
# Here we are applying the Tanh to the tensor
output = th(input)
# Print the output
print(output)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch TanH 激活函数值被打印在屏幕上。
PyTorch TanH activation function
由此，我们了解了 pyhton 的 PyTorch TanH 激活功能。
串层指针
在这一节中，我们将学习 python 中的 PyTorch TanH 层。
PyTorch TanH 图层被定义为计算输入的双曲正切的图层。
代码:
在下面的代码中，我们将导入 torch 模块，如 import torch 和 import torch.nn as nn。
- l = nn。Tanh(): 这里我们调用 Tanh()函数。
- input = torch.randn(9): 这里我们使用 torch.randn()函数声明输入变量。
- output = l(input): 这里我们描述的是输出变量。
- print(" The input:"，input) 用于打印输入的变量。
- print(" output:"，output) 用于打印输出变量。
# Import library
import torch
import torch.nn as nn
# Calling the Tanh() function
l = nn.Tanh()
# Declaring the input variable
input = torch.randn(9)
# Describing the output variable
output = l(input)
# Print the input and output
print(" The input:",input)
print(" The output:",output)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch TanH 图层值打印在屏幕上。
PyTorch TanH layer
这就是我们在神经网络的帮助下对 PyTorch TanH 层的理解。Tanh()函数。
PyTorch TanH 逆
在这一节中，我们将学习 python 中的 PyTorch TanH inverse 。
torch.aTanh()返回一个新的张量，它具有输入元素的反双曲正切值。PyTorch TanH 逆 tangel 的定义域是(-1，1)。
代码:
在下面的代码中，我们将导入 torch 库，如 import torch。
- inver = torch . randn④。uniform_(-3，3) 通过使用 torch.randn()函数来声明逆变量。
- print(" input:"，inver) 用于通过 print()函数打印输入。
- t= torch.atanh(inver): 这里我们称之为逆 tanh。
- print(" Output:"，t) 用于借助 print()函数打印输出。
#Import library
import torch
# Declaring the variable
inver = torch.randn(4).uniform_(-3, 3)
print("The input:",inver)
# Calling the inverse TanH
t= torch.atanh(inver)
# Print the output
print("The Output:", t)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch TanH 逆值打印在屏幕上。
PyTorch TanH inverse
因此，通过使用 Python 中的 atanh()函数，我们了解了 PyTorch TanH 逆运算。
什么是 PyTorch Tanhshrink
在这一节中，我们将学习 python 中的 PyTorch Tanhshrink。
PyTorch Tanhshrink 应用基于元素的函数，即 Tanhshrink = X–tanh(X)。TanH 应用基于元素的双曲正切函数。
代码:
在下面的代码中，我们将导入所有的 torch 库，如 import torch 和 import torch.nn as nn。
- s = nn。Tanhshrink(): 这里我们调用的是 Tanhshrink()函数。
input = torch.randn(4)用于通过使用 torch.randn()函数来声明输入变量。output = s(input)用来描述输出变量。- 打印(输出)用于使用 print()函数打印输出。
# Importing libraries
import torch
import torch.nn as nn
# Calling the Tanhshrink()
s = nn.Tanhshrink()
# Declaring the input variable
input = torch.randn(4)
# Describing the output variable
output = s(input)
# Print output
print(output)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch Tanhshrink 值被打印在屏幕上。
PyTorch Tanhshrink
这就是我们通过 python 使用 Tanhshrink()函数来理解 PyTorch Tanhshrink 的方法。
读取 PyTorch 线性回归
如何使用 PyTorch functional TanH
在本节中，我们将学习 python 中的 PyTorch 函数 TanH 。
PyTorch 泛函双曲正切函数被定义为 nn，functional.tanh()函数，它适用于元素。它是非线性和可微分的，其输出范围在-1 到+1 之间。
语法:
PyTorch 函数的语法是:
torch.nn.functional.tanh(input)
参数:
以下是 PyTorch 泛函正切函数的参数:
输入:输入参数定义为输入张量。
这样，我们通过使用 torch.nn.functional.tanh()函数了解了 PyTorch 泛函 TanH。
PyTorch TanH Vs ReLU
在这一节中，我们将讨论 python 中的 PyTorch TanH Vs ReLU。
Pytorch TanH
PyTorch 双曲正切函数被定义为不同的非线性函数，与 sigmoid 函数相同，输出值在-1 到+1 的范围内。
代码:
在下面的代码中，我们将导入 torch 模块，如 import torch，import torch.nn as nn。
- v = nn。Tanh(): 这里我们定义了 Tanh 函数。
- 输入=火炬。张量([2，-4，5，-7]) 用于通过使用 torch.tensor()函数来描述输入变量。
- output = v(input): 这里我们对张量应用双曲正切。
- 打印(输出)用于借助 print()函数打印输出。
# Import library
import torch
import torch.nn as nn
# Here we are calling the Tanh function
v = nn.Tanh()
# Defining tensor
input = torch.Tensor([2,-4,5,-7])
# Here we are applying Tanh to the tensor
output = v(input)
print(output)
输出:
在下面的输出中，我们可以看到 PyTorch TanH 值打印在屏幕上。
PyTorch TanH
PyTorch ReLU
PyTorch ReLU 也是一个非线性且可微的函数。在 ReLU 中，如果输入是负的，那么它的导数变为零，神经元的学习速率停止。
代码:
在下面的代码中，我们将导入 torch 模块，如 import torch，import torch.nn as nn。
- v = nn。ReLU(): 这里我们调用 ReLU()函数。
- 输入=火炬。张量([2，-4，5，-7]) 用于创建一个带数组的张量。
- output = v(input): 这里我们将数组传递给 relu 函数。
- 打印(输出)用于使用 print()函数打印输出。
# Import library
import torch
import torch.nn as nn
# Here we are calling the relu
v = nn.ReLU()
# Creating a Tensor with an array
input = torch.Tensor([2, -4, 5, -7])
# Passing the array to relu function
output = v(input)
# Print the output
print(output)
输出:
在下面的输出中，我们可以看到 PyTorch ReLU 值打印在屏幕上。
PyTorch ReLU
这样，我们理解了 python 中 PyTorch TanH 和 ReLU 之间的区别。
您可能会喜欢以下 PyTorch 教程:
- pytorch league relu
- 【numpy 指针为张量
- PyTorch 激活功能
- py torch nn s 形教程
- rn 指针
- PyTorch 全连接层
因此，在本教程中，我们讨论了 PyTorch TanH ,我们还讨论了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- 什么是 PyTorch TanH
- PyTorch TanH 示例
- PyTorch TanH inplace
- PyTorch TanH 激活函数
- 塔赫纳层
- PyTorch TanH 逆
- 什么是 PyTorch Tanhshrink
- 如何使用 PyTorch 功能性 TanH
- 皮托奇·塔恩 vs·里尔
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
张量积是 Numpy
在这个 Python 教程中，我们将学习关于 PyTorch 张量到 NumPy 的知识，我们还将涵盖与 PyTorch 张量到 NumPy 相关的不同示例。我们将讨论这些话题。
- 张量积是 numpy
- PyTorch 张量到 numpy 分离
- PyTorch 张量到 numpy 浮点
- PyTorch 张量到 numpy CPU
- 张量积是 numpy int
- 张量张量为 numpy dtype
- PyTorch 张量到 numpy GPU
- PyTorch Cuda 张量到 numpy
- 将 PyTorch 张量变换为 numpy
目录
- 指针为 NumPy
- PyTorch 张量到 numpy 分离
- PyTorch 张量到 numpy 浮点
- 指针是指 CPU 的 numpy】
- 指针是指 numpy int
- PyTorch 张量到 numpy dtype
- PyTorch 张量到 numpy GPU
- PyTorch Cuda 张量到 NumPy
- 将 PyTorch 张量转换为 numpy
指针为 NumPy
在这一节中，我们将学习如何在 python 中将 PyTorch 张量转换为 NumPy 。
- PyTorch 张量与 numpy 数组相同，它只是一个简单的 n 维数组，用于任意数值计算。
- PyTorch tensor to numpy 定义为占用 CPU 并与 numpy 数组共享相同内存的进程。
代码:
在下面的代码中，我们将导入一些库，从中可以看到张量到 NumPy 数组的转换。
- m = torch.tensor([12.14，22.58，32.02，42.5，52.6]) 用于创建具有浮点类型元素的一维张量。
print(m)用于在屏幕上打印张量数组。m = m.numpy()是用来将张量转换成 numpy 数组的方法。m这个 m 用来在屏幕上显示 numpy 数组。
**# importing torch module**
import torch
**# import numpy module**
import numpy as num
m = torch.tensor([12.14, 22.58, 32.02, 42.5, 52.6])
print(m)
m = m.numpy()
m
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到张量数组正在转换成 NumPy 数组，结果打印在屏幕上。
PyTorch tensor to NumPy
同样，检查:交叉熵损失 PyTorch
PyTorch 张量到 numpy 分离
在本节中，我们将了解如何在 python 中将 PyTorch 张量转换为 numpy detach 。
PyTorch tensor to numpy detach 定义为从 CPU 分离张量的过程，之后使用 numpy() 进行 numpy 转换。
代码:
在下面的代码中，我们将导入 torch 模块，从中可以看到 tensor 到 numpy detach 的转换。
- tensor array = torch . tensor([[15，25，35]，[45，55，65]，[75，85，95]]) 用于创建张量数组。
print(tensorarray)用于在屏幕上打印张量数组。- numpyarray= tensorarray.cpu()。分离()。numpy() 用于将张量收敛到 numpy detach。
numpyarray用于在屏幕上显示 numpy 数组。
import torch
tensorarray = torch.tensor([[15,25,35],[45,55,65],[75,85,95]])
print(tensorarray)
numpyarray= tensorarray.cpu().detach().numpy()
numpyarray
输出:
在下面的输出中，我们可以看到张量到 numpy detach 的转换显示在屏幕上。
PyTorch tensor to numpy detach
PyTorch 张量到 numpy 浮点
在这一节中，我们将学习如何在 python 中将 PyTorch 张量转换成 NumPy float 。
- 在前进之前，我们应该有一个关于浮动的知识。Float 是一种数据类型，包括以十进制格式表示的分数。
- PyTorch tensor to numpy float 用于将张量数组转换为 numpy float 数组。
代码:
在下面的代码中，我们将导入 torch 模块，用于张量到 NumPy float 的转换。
- tensor array = torch . tensor([[2。，3，4]，[5，6，7]，[8，9，10]]，requires_grad=True) 用于创建张量数组。
print(tensorarray)用于在屏幕上打印张量数组。- numpyarray = tensor array . detach()。numpy() 用于将张量数组转换为 numpy 浮点数。
numpyarray用于在屏幕上显示 numpy 数组。
import torch
tensorarray = torch.tensor([[2.,3,4],[5,6,7],[8,9,10]],requires_grad=True)
print(tensorarray)
numpyarray = tensorarray.detach().numpy()
numpyarray
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到张量数组被转换为 NumPy 浮点数组。
PyTorch tensor to NumPy float
阅读: PyTorch 批量标准化
指针是指 CPU 的 numpy】
在这一节中，我们将学习如何用 python 将张量转换成 numpy CPU。
- PyTorch 张量与 numpy 数组相同，它只是一个简单的 n 维数组，并使用任意数值计算。
- PyTorch 张量到 numpy CPU 是张量到 numpy CPU 的转换过程。张量存储在 CPU 上，共享同一个内存。
代码:
在下面的代码中，我们将导入一些库，从这些库中可以完成张量到 numpy CPU 的转换。
- tensor array = torch . tensor([[25，35，45]，[55，65，75]，[85，95，15]]) 用于创建张量数组。
print(tensorarray)用于在屏幕上打印张量数组。- numpyarray= tensorarray.cpu()。numpy() 用于将张量转换为 numpy CPU。
numpyarray用于在屏幕上显示 numpy 数组。
import torch
import numpy
tensorarray = torch.tensor([[25,35,45],[55,65,75],[85,95,15]])
print(tensorarray)
numpyarray= tensorarray.cpu().numpy()
numpyarray
输出:
在下面的输出中，我们可以看到张量到 numpy CPU 的转换被打印在屏幕上。
PyTorch tensor to NumPy CPU
指针是指 numpy int
在本节中，我们将学习 python 中的 PyTorch tensor 到 numpy int 。
PyTorch tensor to NumPy int 定义为我们将张量数组转换为数组中 NumPy 的过程。
代码:
在下面的代码中，我们将导入一些库，从中我们可以将数组张量转换为 numpy。
- m = tf.constant([[3，4]，[5，6]]) 用于创建张量数组。
print(m)用于打印 m 的值m.numpy()用于将 Pytorch 张量转换为 numpy。
import tensorflow as tf
import numpy
m = tf.constant([[3, 4], [5, 6]])
n = tf.add(m, 3)
print(m)
m.numpy()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 张量到 numpy inst 被打印在屏幕上。
PyTorch tensor to numpy int
PyTorch 张量到 numpy dtype
在这一节中，我们将学习 python 中 NumPy dtype 的 PyTorch 张量。
- 在继续之前，我们应该了解一些关于 dtype 的知识。
- dtype 是一种数据类型，它描述了固定大小的内存块与数组保持联系的字节数。数据类型的类型有整型、浮点型等。
- PyTorch 张量到 numpy dtype 定义为将张量转换为 numpy dtype 数组的过程。
代码:
在下面的代码中，我们将导入一些库，从这些库中我们可以将 tensor 转换为 numpy dtype。
- 张量= torch.tensor([[5。，10，15]，[20，25，30]，[35，40，45]]) 用于创建张量数组。
print(tensor)用于在屏幕上打印张量数组。numpy = tensor.numpy()用于将张量转换为 numpy 数组。
import torch
import numpy
tensor = torch.tensor([[5.,10,15],[20,25,30],[35,40,45]])
print(tensor)
numpy = tensor.numpy()
numpy
输出:
在下面的输出中，我们可以看到 PyTorch 张量到 numpy dtype 被打印在屏幕上。
PyTorch tensor to NumPy dtype
阅读 PyTorch 逻辑回归
PyTorch 张量到 numpy GPU
在本节中，我们将学习 python 中的 PyTorch 张量到 NumPy GPU 。
张量可以从 numpy 数组中生成，它类似于 NumPy，其属性描述数据类型、形状等。
代码:
在下面的代码中，我们将导入 torch 模块，从中我们可以将张量转换为 numpy GPU 数组。
torch.eye(2)函数返回大小为 m*n 的 2d 张量。a.to("cuda")Cuda 是一种应用编程接口，允许软件使用某些类型的图形处理单元(GPU)。- a . to(“CPU”)。numpy() 用于将张量转换为 numpy。
import torch
a = torch.eye(2)
a = a.to("cuda")
a.to("cpu").numpy()
输出:
运行上述代码后，我们得到以下输出，其中我们可以看到 PyTorch 张量到 NumPy GPU 数组打印在屏幕上。
PyTorch tensor to NumPy GPU
PyTorch Cuda 张量到 NumPy
在本节中，我们将学习如何在 python 中将 PyTorch Cuda tensor 转换为 numpy 。
- 在继续之前，我们应该了解一些关于 Cuda 的知识。
- Cuda 代表计算统一设备架构，这是一个应用程序编程接口，允许软件使用特定类型的 GPU。
- PyTorch Cuda tensor to numpy 定义为将 Cuda tensor 转换为 numpy 数组的过程。
代码:
在下面的代码中，我们将导入一些库，我们可以从中创建张量，然后将张量转换为 NumPy。
- tensor = torch.tensor([2，4，6，8，10]，dtype=torch.float32，requires_grad=True)。cuda() 用于在 GPU 上创建张量。
print(tensor)用于在屏幕上打印张量数组。- num = tensor.detach()。cpu()。numpy() 用于将张量转换为 numpy。
num用于在屏幕上显示 numpy 数组。
import torch
import numpy
**# Create tensor on the GPU**
tensor = torch.tensor([2, 4, 6, 8, 10], dtype=torch.float32, requires_grad=True).cuda()
print(tensor)
num = tensor.detach().cpu().numpy()
num
输出:
在下面的输出中，我们可以看到 PyTorch Cuda 张量到 numpy 数组的转换被打印在屏幕上。
PyTorch Cuda tensor to numpy
阅读: PyTorch 数据加载器+示例
将 PyTorch 张量转换为 numpy
在这一节中，我们将学习如何用 python 将 PyTorch 张量转换成 numpy。
将 PyTorch 张量转换为 numpy 定义为将 PyTorch 张量转换为 numpy 数组的过程。
代码:
在下面的代码中，我们将导入一些库，从中我们可以将 PyTorch 转换为 numpy。
- m = torch.tensor([[2，4，6，8，10]，[3，6，9，12，15]，[4，8，12，16，20]]) 用于创建具有整数类型元素的二维张量。
print(m)用于打印张量数组。m = m.numpy()用于将张量转换为 numpy 数组。m用于在屏幕上显示 numpy 数组。
import torch
import numpy
m = torch.tensor([[2, 4, 6, 8, 10], [3, 6, 9, 12, 15],
[4, 8, 12, 16, 20]])
print(m)
m = m.numpy()
m
输出:运行上面的代码后，我们得到下面的输出，其中我们可以看到张量到 NumPy 数组的转换被打印在屏幕上。
Transform PyTorch tensor to numpy
因此，在本教程中，我们讨论了从 PyTorch 张量到 numpy 的关系，并且讨论了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- 张量积是 numpy
- PyTorch 张量到 numpy 分离
- PyTorch 张量到 numpy 浮点
- PyTorch 张量到 numpy CPU
- 张量积是 numpy int
- 张量张量为 numpy dtype
- PyTorch 张量到 numpy GPU
- PyTorch Cuda 张量到 numpy
- 将 PyTorch 张量变换为 numpy
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
PyTorch 视图教程[有 11 个例子]
本 PyTorch 教程将讲解 Python 中 PyTorch 视图的用法。 *PyTorch view()* 函数返回一个具有相似数据数量的新张量，并且应该具有相似数量的元素。
此外，我们还将介绍与 PyTorch 视图相关的不同示例。我们将讨论这些话题。
- PyTorch view
- PyTorch 视图示例
- PyTorch 视图批处理大小
- PyTorch 视图连续
- PyTorch 视图展平
- NumPy 的 PyTorch 视图
- PyTorch view size
- PyTorch 视图转置
- PyTorch 视图整形
- PyTorch view unsqueeze
- PyTorch 创建一个 8 元素的张量和 2 行 4 列的视图
- PyTorch 将张量视图更改为 8 行 1 列
目录
- 视图指针
- PyTorch 视图示例
- PyTorch 视图批处理大小
- PyTorch 视图连续
- PyTorch 视图展平
- numpy 中的 PyTorch 视图
- 视图大小指针
- PyTorch 视图转置
- PyTorch 视图重塑
- PyTorch view unsqueeze
- PyTorch 创建具有 8 个元素的张量和具有 2 行 4 列的视图
- PyTorch 将张量视图变为 8 行 1 列
视图指针
在本节中，我们将学习 python 中的 PyTorch 视图。
*PyTorch view()* 函数用于将张量转换为 2D 格式，即行和列。我们应该有一定数量的行和列来查看。
语法:
PyTorch 视图的语法是:
tensor.view(no_of_rows, no_of_columns)
参数:
- 行数:我们可以查看几行。
- 列数:我们可以查看一些列。
这就是我们对 PyTorch 视图函数的理解。
另外，请查看:py torch Lenet 简介
PyTorch 视图示例
在这一节中，我们将借助一个例子来了解如何实现 PyTorch 视图。
PyTorch view()函数返回一个具有相似数据数量的新张量，并且应该具有相似数量的元素。
代码:
在下面的代码中，我们将导入 torch 库，如 import torch。
- a = torch.randn(6，6): 这里我们用
torch.randn()函数声明一个变量。 - b = a.view(36): 这里我们用 view()函数来描述一个变量。
- c = a.view(-1，12): 这里的 size -1 是从其他维度推导出来的。
# Import library
import torch
# Describe a variable
a = torch.randn(6, 6)
torch.Size([6, 6])
# Using view() function
b = a.view(36)
# Print output
print(b)
b.size()
torch.Size([36])
# The size -1 is deduced from other dimensions
c = a.view(-1, 12)
print(c)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到，使用 view()函数后，新的张量被返回，新张量的值被打印在屏幕上。
PyTorch view example
这样，我们借助一个例子理解了 PyTorch 的观点。
阅读: PyTorch 添加尺寸
PyTorch 视图批处理大小
在本节中，我们将学习 python 中的 PyTorch 视图批处理大小。
在继续之前，我们应该对批量大小有所了解。
批量被定义为一个过程，在该过程中，模型之前制备的样品数量被更新。
PyTorch 视图 batchsize 用于返回具有相似数量数据的新张量。
代码:
在下面的代码中，首先我们将导入 torch 库，如 import torch。
- pertens = torch.tensor([1，3，4]): 这里我们用 torch.tensor()函数声明 pertens 变量。
- pertens.view(3): 这里我们使用 view()函数，它返回具有相似数量数据的新张量。
# Import library
import torch
# Describe a variable
pertens = torch.tensor([1,3,4])
# Using view() function
pertens.view(3)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 批处理大小值被打印在屏幕上。
PyTorch view batchsize
这就是我们对 PyTorch 视图批量大小的理解。
阅读: PyTorch 超参数调谐
PyTorch 视图连续
在本节中，我们将学习 python 中的 PyTorch 视图连续。
在继续之前，我们应该了解一些关于连续的知识。
连续被定义为顺序上的下一个或一起，或者我们可以说共享一个公共边界。
这里我们从产生非连续张量的连续张量的观点出发。
代码:
在下面的代码中，我们将导入 torch 模块，如 import torch。
- c = torch.rand(6，6): 这里我们用 torch.rand()函数来描述一个变量。
- c .存储()。data_ptr() == b.storage()。data_ptr() 用于共享相同的底层数据。
- s = torch.tensor([[1，2]，[3，4]]): 这里我们用 torch.tensor()函数声明 s 变量。
- c = s.transpose(0，1): 这里 c 是 s 的一个视图。
- m = c.contiguous(): 这里我们通过调用 contiguous()函数，复制 c 不连续时的数据，得到一个连续张量。
# Import library
import torch
c = torch.rand(6, 6)
d = c.view(4, 9)
# c and d share the same underlying data.
c.storage().data_ptr() == b.storage().data_ptr()
# Modifying view tensor changes base tensor as well.
d[0][0] = 3.14
c[0][0]
s = torch.tensor([[1, 2],[3, 4]])
s.is_contiguous()
# c is a view of s.
c = s.transpose(0, 1)
# View tensors might be non-contiguous.
c.is_contiguous()
# Here we get a contiguous tensor by calling contiguous() function
# And copying the data when c is not contiguous.
m = c.contiguous()
print(m)
输出:
运行上面的代码后，我们得到了下面的输出，其中我们可以看到 PyTorch 视图的连续值被打印在屏幕上。
PyTorch view contiguous
这就是我们如何理解 PyTorch 视图的连续。
阅读: PyTorch 线性回归
PyTorch 视图展平
在这一节中，我们将学习 python 中的 PyTorch 视图展平。
展平被定义为用于将 n 维张量展平为一维张量的过程。
代码:
在下面的代码中，我们将导入 torch 库，如 import torch。
- a = torch.tensor([[2，4，6，8，10，12]，[2，4，6，8，10，12]]): 这里我们使用 torch.tensor()函数创建一个有六个元素的二维张量。
print(a)用于显示一个实际的张量。print(torch.flatten(a))用 flatten()函数展平一个张量。- a.view(2，6) :这里我们使用一个 view()函数返回一个新的张量。
# import torch module
import torch
# create an two dimensional tensor with 6 elements each
a = torch.tensor([[2,4,6,8,10,12],
[2,4,6,8,10,12]])
# Here we are displaying actual tensor
print(a)
# flatten a tensor with flatten() function
print(torch.flatten(a))
# Using view() function
a.view(2,6)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 视图的展平值被打印在屏幕上。
PyTorch view flatten
由此，我们理解了 PyTorch 视图的扁平化。
numpy 中的 PyTorch 视图
在本节中，我们将学习 python 中 numpy 中的 PyTorch 视图。
Pytorch 视图用于在 torch 张量上注册以转换其形状。并在整形(numpy()函数)的帮助下转换 ndarray 的形状。
代码:
在下面的代码中，首先我们导入 torch 库，比如 import torch。
- m = torch.ones((4，6，8)): 这里我们用 torch.ones()函数声明一个变量。
- m.view(-1，12)。size(): 这里我们使用 view()函数来返回新的张量。
- 火炬。Size([2，12]): 这里我们使用 torch.size()函数声明大小。
# Import library
import torch
# Describe a variable
m = torch.ones((4, 6, 8))
m.size()
torch.Size([4, 6, 8])
# Using view() function
m.view(-1, 12).size()
# Declaring the size
torch.Size([2, 12])
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到在 numpy 值中的 PyTorch 视图被打印在屏幕上。
PyTorch view in NumPy
由此，我们了解了 numpy 的 PyTorch 景观。
视图大小指针
在本节中，我们将学习 python 中的 PyTorch 视图大小。
正如我们所知，PyTorch view()函数返回具有相似数据的新张量，并且应该具有相似数量的元素，但大小不同。视图大小可以与其实际大小一致。
代码:
在下面的代码中，首先我们将导入 torch 库，如 import torch。
- x = torch.randn(2，4，6，8): 这里我们用 torch.randn()函数来描述一个变量。
- 火炬。尺寸([2，4，6，8]) 用来定义一个张量的大小。
- y = x.view(2，6，4，8): 这里我们使用的是 view()函数，它不会改变张量在内存中的布局。
- 这里我们定义了视图的大小。
# Import Library
import torch
# Describing a variable
x = torch.randn(2, 4, 6, 8)
# Define the size of the tensor
x.size()
torch.Size([2, 4, 6, 8])
# Using view() function that does not change tensor layout in a memory
y = x.view(2, 6, 4, 8)
# Define the size of the view
y.size()
输出:
运行上面的代码后，我们得到了下面的输出，其中您可以看到 PyTorch 视图大小值被绘制在屏幕上。
PyTorch view size
至此，我们了解了 PyTorch 视图的大小。
阅读: PyTorch MNIST 教程
PyTorch 视图转置
在本节中，我们将学习 python 中的 PyTorch 视图转置。
PyTorch 视图转置被定义为将张量转移到不同的上下文或位置的过程，或者我们可以说改变两个或更多事物的位置。
代码:
在下面的代码中，我们将导入 torch 库，如 import torch。
- x = torch.randn(4，8，16，24): 这里我们用 torch.randn()函数来描述一个变量。
- 火炬。Size([4，8，16，24]): 这里我们定义张量的大小。
- y = x.transpose(2，3): 这里我们是交换第三和第四维。
- z = x.view(4，8，24，16): 这里我们使用的是 view()函数，不改变张量在内存中的布局。
# Import Library
import torch
# Describing a variable
x = torch.randn(4,8,16,24)
# Define the size of the tensor
x.size()
torch.Size([4,8,16,24])
# Here we are swapping the third and fourth dimension
y = x.transpose(2, 3)
y.size()
torch.Size([4,8,16,24])
# Using view() function that does not change tensor layout in a memory
z = x.view(4,8,24,16)
z.size()
torch.Size([4,8,24,16])
torch.equal(y, z)
输出:
在下面的输出中，您可以看到 PyTorch 视图移调值打印在屏幕上。
PyTorch view transpose
至此，我们了解了 PyTorch 视图转置。
阅读: PyTorch 双星交叉熵
PyTorch 视图重塑
在本节中，我们将学习 python 中的 PyTorch 视图整形。
PyTorch 视图整形功能用于将尺寸整形或更改为给定的形状。张量被定义为输入张量。
代码:
在下面的代码中，我们将导入 torch 库，如 import torch。
- r = torch.tensor([2，4，6，8，10，12]): 这里我们通过使用 torch.tensor()函数创建一个带有 size 元素的一维张量。
print(r.shape)用于打印张量形状。print(r)用于显示实际形状。- print(r . shape([3，2])用于将张量整形为三行两列。
print(r.shape)用于显示整形张量的形状。- r.view(3，2): 这里我们使用一个 view()函数返回新的张量。
# Import linrary
import torch
# Here we are creating a one-dimensional tensor with 6 elements
r = torch.tensor([2, 4, 6, 8, 10, 12])
# Showing tensor shape
print(r.shape)
# Showing actual tensor
print(r)
# Reshape tensor into 3 rows and 2 columns
print(r.reshape([3, 2]))
# Showing the shape of reshaped tensor
print(r.shape)
# Using view() function
r.view(3,2)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 视图整形值被打印在屏幕上。
PyTorch view reshape
由此，我们了解了 PyTorch 观点的重塑。
阅读: PyTorch 数据加载器+示例
PyTorch view unsqueeze
在这一节中，我们将学习 python 中的 PyTorch 视图 unsqueeze 。
在前进之前，我们应该有一个关于 unsqueeze 的知识。
unsqueeze() 函数返回一个新的张量，其维数为 1，插入到定义的位置。
代码:
在下面的代码中，我们将导入 torch 库，如 import torch。
- a = torch.tensor([2，3，4，5]): 这里我们用 torch.tensor()函数来描述变量。
- m=torch.unsqueeze(a，0): 这里我们使用 unsqueeze()函数来添加维度。
print(m)用于借助 print()函数打印输出。- m.view(2，2): 这里我们使用 view()函数返回新的张量。
# Import library
import torch
# Declare a variable
a = torch.tensor([2, 3, 4, 5])
# Using unsqueeze() method to add dimension
m=torch.unsqueeze(a, 0)
# Print output
print(m)
# Using view() function
m.view(2,2)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 视图的 unsqueeze 值被打印在屏幕上。
PyTorch view unsqueeze
这就是我们如何理解 PyTorch 视图挤压的原因。
阅读: PyTorch 提前停止+示例
PyTorch 创建具有 8 个元素的张量和具有 2 行 4 列的视图
在本节中，我们将学习如何在 PyTorch 中创建一个包含 8 个元素的张量和一个包含 2 行 4 列的视图。
这里我们使用的是 view()函数。view()函数用于将张量转换为二维格式的行和列，这里我们创建了一个包含 8 个元素的张量和一个包含 2 行 4 列的视图。
代码:
在下面的代码中，首先我们导入 torch 库，比如 import torch。
- a =火炬。FloatTensor([25，30，35，40，45，50，55，60]): 这里我们创建一个有 8 个元素的一维张量。
- print(a.view(2，4)) 用于查看 2 行 4 列的张量。
- print(a.view(2，4)) 用于查看 3 行 4 列的张量。
# import torch library
import torch
# Here we are creating one dimensional tensor with 8 elements
a=torch.FloatTensor([25, 30, 35, 40,
45,50,55,60])
# view tensor in 2 rows and 4 columns
print(a.view(2, 4))
# view tensor in 3 rows and 4 columns
print(a.view(2, 4))
输出:
运行上面的代码后，我们得到了下面的输出，其中我们可以看到屏幕上打印了具有 8 个元素的 PyTorch 一维张量和具有 2 行 4 列值的视图。
PyTorch to create a tensor with 8 elements and view with 2 rows and 4 columns
这样，我们就了解了如何创建一个 8 元素的张量和 2 行 4 列的视图。
阅读: PyTorch 预训练模型
PyTorch 将张量视图变为 8 行 1 列
在这一节中，我们将学习如何在 PyTorch 中将一个张量的视图变成八个 行和一个列。
正如我们所知，PyTorch 视图函数用于将张量转换为行和列的 2D 格式。我们应该有一定数量的行和列来查看。
代码:
在下面的代码中，我们将导入 torch 模块，如 import torch。
- a =火炬。FloatTensor([25，30，35，40，45，50，55，60]): 这里我们创建一个有八个元素的一维张量。
- print(a.view(8，1)): 这里我们查看的是 8 行 1 列的张量。
- print(a.view(1，8)): 这里我们正在查看 1 行 8 列的张量。
# import torch
import torch
# Here we are creating one dimensional tensor 8 elements
a = torch.FloatTensor([25, 30, 35, 40,
45,50,55,60])
# Here we are viewing tensor in 8 rows and 1 column
print(a.view(8, 1))
# Here we are viewing tensor in 1 row and 8 columns
print(a.view(1, 8))
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到屏幕上打印了将视图张量更改为 8 行和 1 列的值。
PyTorch to change the view of a tensor into 8 rows and 1 column
这就是我们如何理解如何将一个张量的视图变成 8 行。
您可能也喜欢阅读下面的 Python PyTorch 教程。
因此，在本教程中，我们讨论了 PyTorch 视图,我们还讨论了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- PyTorch view
- PyTorch 视图示例
- PyTorch 视图批处理大小
- PyTorch 视图连续
- PyTorch 视图展平
- numpy 的 PyTorch 视图
- PyTorch view size
- PyTorch 视图转置
- PyTorch 视图整形
- PyTorch view unsqueeze
- PyTorch 创建一个 8 元素的张量和 2 行 4 列的视图
- PyTorch 将张量视图更改为 8 行 1 列
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Python 中读取视频帧
在本 python 教程中，我们将讨论如何在 python 中读取视频帧， Python 读取视频帧，我们还将讨论以下主题:
- Python 读取视频帧
- Python 从视频中提取特定帧
目录
Python 读取视频帧
这里可以看到如何用 python 读取视频帧。
- 在这个例子中，我导入了名为
cv2和os的模块。 - 接下来，我们应该读取视频的路径。
- 这里，我们使用
os.makedirs创建一个名为 pet 的文件夹，将视频的帧复制到该文件夹中。宠物是文件夹的名字。 - 我使用了异常，如果文件夹没有被创建，它会产生一个错误。
- 当我们使用框架时，我们应该提到当前框架来使用它。
- ret 用于返回帧。使用 while 条件，如果该条件为真，则将视频读入文件夹。
- 读取图像。使用 jpg 扩展名。将编号分配给文件夹中的每个框架 currentframe += 1。
- 如果条件为假，则执行 else，使用
video.release()来释放对象。 - cv2.destroyAllWindows() 简单地销毁所有创建的窗口。
举例:
import cv2
import os
video = cv2.VideoCapture(r'C:\Users\Administrator.SHAREPOINTSKY\Downloads\catty.mp4')
try:
if not os.path.exists('pet'):
os.makedirs('pet')
except OSError:
print ('Error')
currentframe = 0
while(True):
ret,frame = video.read()
if ret:
name = './pet/frame' + str(currentframe) + '.jpg'
print ('Captured...' + name)
cv2.imwrite(name, frame)
currentframe += 1
else:
break
video.release()
cv2.destroyAllWindows()
下面的截图显示了作为输出的帧的创建。
Python read video frames
作为输出，我们可以看到文件夹中的视频帧。下面的截图显示了输出。
Python read video frames
这就是如何在 Python 中读取视频帧。
Python 从视频中提取特定帧
在这里，我们可以看到如何用 python 从视频中提取特定的一帧。
- 在这个例子中，我将一个名为 numpy 的模块作为 np 和
cv2导入，然后通过指定路径读取文件。 - 为了给出帧的值，使用 cap.set(1，16) 。这里，16 是帧的编号。
- 使用 cap.read 读取帧。我已经使用了
cv2.imshow()来显示指定帧的图像。
示例:
import numpy as np
import cv2
cap = cv2.VideoCapture(r'C:\Users\Administrator.SHAREPOINTSKY\Downloads\catty.mp4')
cap.set(1,16);
ret, frame = cap.read()
cv2.imshow('window_name', frame)
下面的截图显示了视频中指定的帧
Python extract a specific frame from video
这就是如何用 Python 从视频中提取特定帧。
您可能会喜欢以下 Python 教程:
- Python 熊猫中的 group by
- Python 程序打印数组中的元素
- Python 熊猫中的交叉表
- Python 二叉树实现
- Python 字符串格式化示例
- Python 程序打印质数
- Python 中的 NumPy 是什么
在本教程中，我们已经了解了 Python 读取视频帧，并且我们还涵盖了以下主题:
- Python 读取视频帧
- Python 从视频中提取特定帧
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
使用 Tkinter 的 Python 注册表+使用数据库 SQLite3 的 Python Tkinter 登录页面
原文：https://pythonguides.com/registration-form-in-python-using-tkinter/
这篇完整的 python 教程解释了如何使用 Python Tkinter 创建一个注册表单，以及如何使用数据库 sqlite3 在 Python Tkinter 中创建一个登录页面。此外，我还解释了如何在 Python Tkinter 中验证注册表单中的表单字段。我希望，你会喜欢这个，注册表在 Python 中使用 Tkinter** 的例子。**
所有数据将使用 SQLite3 数据库存储和提取。这是一个关于数据库的 python 中的注册表单的完整项目，它可以用于在 Python 中的任何桌面应用程序中添加注册&登录屏幕。
目录
- 使用 Tkinter 在 Python 中登录和注册表单概述
- Python Tkinter 注册表
- 使用数据库在 Python Tkinter 中登录页面
- 对空字段使用 tkinter 验证的登记表
- 将 Python Tkinter 注册表单数据保存到 sqlite3
使用 Tkinter 在 Python 中登录和注册表单概述
- 使用 Python 库'
Tkinter'创建登录和注册表单[阅读更多关于 Python Tkinter - Tkinter 允许创建基于 GUI 的应用程序,并且有很多有用的小部件。
- 对于数据库，我们使用了 python 预装的 SQLite3 。它是 SQL 的简化版本，可以存储 281 的数据。
- 我们已经在项目中的所有输入字段上添加了验证，这意味着必须提供所有信息。不这样做将提示一条错误消息。
- 异常处理程序是用来避免中断程序的，你也可以通过消息框看到错误。
- 下拉列表中显示了'北美'大陆的所有国家的名称。如果您想添加更多的国家，只需将 countries.txt 替换为您的文本文件，但一定要更改第 129 行代码中的名称。更简单的方法是编辑 inside
countries.txt的数据。 - 下面是对程序中使用的小部件的描述。此外，我们有一个项目中使用的每个部件的专用部分，我们在每个部件前面添加了一个链接。
| Widget Name | 小部件概述 |
|---|---|
| Python Tkinter 帧 | 我们使用了两个名为左帧 & 右帧的帧。他们定位登录和注册页面。用于定位框架的几何图形管理器是 Place。 |
| Tkinter 标签 | 标签小部件用于在应用程序屏幕上显示文本。屏幕上的所有文本，如“输入电子邮件”、“输入姓名”等，都是使用标签小部件添加的。 |
| 入口小部件 | 输入框为用户提供空白空间，用户可以在其中输入详细信息。它是任何应用程序中使用的最重要的小部件之一。 |
| Python Tkinter 单选按钮 | Radiobutton 小部件用于向用户提供单一选择。在应用程序中。用户一次只能选择一种性别。 |
| 选项菜单 | OptionMenu 用于显示下拉菜单。它用于在应用程序中显示国家列表。了解有关 OptionMenu 的更多信息。 |
| 按钮 | 按钮用于在被点击时执行一个动作。在这个应用程序中，我们使用了两个名为 Login 和 Register 的按钮。 |
Widgets used in the application
Login and registration form in python using tkinter
使用 Tkinter 中的 pyqrcode 读取 Python QR 码生成器
Python Tkinter 注册表
在本节中，我们将讨论使用 tkinter 的 python 中的注册表。我们将在那时讨论小部件以及使用它们的目的。这里分享的代码只针对注册页面的界面。完整的应用程序代码在页面底部共享。
框架 小工具
- ws 是我们将要放置框架的主窗口
bd是框架的边界bg是背景色。- 浮雕是提供一种特殊效果。
- 这里使用的几何方法是' pack' ,但在下面的完整代码中，我们使用了位置,因为位置允许我们以更高的精度定位小部件。
- 创建这个小部件的想法是将其他小部件放入其中，这样一切看起来都很有条理。
right_frame = Frame(
ws,
bd=2,
bg='#CCCCCC',
relief=SOLID,
padx=10,
pady=10
)
right_frame.pack()
标签 小工具
- 标签用于向应用程序添加文本。我们已经多次使用标签来显示不同的文本。
- 这里我将解释一次，这将适用于程序中使用的所有标签。
- 在下面的代码中，Label 是用于创建标签小部件的关键字。
- 我们将这个标签放在右帧上。
- 此处添加的任何文本将显示在应用程序上
- 我们使用网格作为几何方法来定位文本。
Label(
right_frame,
text="Enter Name",
bg='#CCCCCC',
font=f
).grid(row=0, column=0, sticky=W, pady=10)
入口小工具
- 条目小部件用于接收用户的输入。它提供了一个空白空间，用户可以在其中键入任何文本。
- 入口小部件在代码中多次使用，这个解释在所有。
- Entry 关键字用于所有的调用入口小工具，它被放置在
right_frame - 我们使用网格作为几何方法来定位文本。
register_name = Entry(
right_frame,
font=f
)
register_name.grid(row=0, column=1, pady=10, padx=20)
单选按钮
- 单选按钮用于向用户提供多个选项，但用户只能选择一个选项。
- 我们创建了另一个名为' gender_frame' 的框架来容纳所有的单选按钮。
text是我们想要显示在单选按钮旁边的名字，例如本例中的“男性”。bg是单选按钮的背景色。- 变量意味着值将会改变，所以在这种情况下，我们将它设置为变量，也就是字符串变量()。现在提供的值必须是一个字符串。如果 var 设置为
IntVar()在这种情况下，值应该是一个整数。 - 值可以是整数或字符串，这取决于我们使用的变量类型。值有助于识别选择了哪个单选按钮。
- 包几何方法被用来在允许的空间内展开&坚守自己的左侧。
- 当 3 个单选按钮以相同的属性放置时，它们看起来都是一样的，有组织的。
var = StringVar()
var.set('male')
male_rb = Radiobutton(
gender_frame,
text='Male',
bg='#CCCCCC',
variable=var,
value='male',
font=('Times', 10),
)
male_rb.pack(expand=True, side=LEFT)
选项菜单
OptionMenu用于在应用程序中创建下拉菜单。显示大数据并不理想，因为它没有滚动条，但它占用的空间较少，并显示适当数量的选项。- 我们使用 OptionMenu 来显示北美大陆的国家列表。
- 在步骤 1 下，我们使用关键字 OptionMenu 来创建小工具，并将其放置在
right_frame内，分配的变量是 StringVar()，这意味着将涉及不同的字符串值。*国家指名单上的所有国家。 - 在步骤 2 下，我们有国家= [] ，这是一个空列表，它将被附加上国家名称。
variable =StringVar()表示字符串会不断变化。 - 在第三步中，我们从一个文本文件中读取国家名称，然后使用一个循环将每个国家追加到列表中。
country.rstrip('\n')它从列表中删除。 - 网格是用于定位微件的几何方法。
# step 2
countries = []
variable = StringVar()
# step 3
world = open('countries.txt', 'r')
for country in world:
country = country.rstrip('\n')
countries.append(country)
variable.set(countries[22])
# step 1
register_country = OptionMenu(
right_frame,
variable,
*countries)
# step 4
register_country.grid(row=4, column=1, pady=10, padx=20)
按钮
- Python Tkinter 中的按钮用于触发活动。当它被点击时应该会发生一些事情。
- 在这个应用程序中，按钮用于保存数据库中的数据。
- Button 关键字用于创建一个小部件，它被放置在 right_frame 中。
- 宽度是按钮的左右间距
- 文本是按钮上显示的名称。
- 光标是鼠标指针的图标。我们使用了手 2 ，这意味着每当用户将光标放在按钮上时，光标就会变成一个指向的手指。
- 命令保存了关于点击按钮会发生什么的信息。这里我们将它设置为 None，这意味着什么都不会发生，但是在完整的代码中，我们为它提供了一个函数名。
register_btn = Button(
right_frame,
width=15,
text='Register',
font=f,
relief=SOLID,
cursor='hand2',
command=None
)
使用 tkinter 代码的登记表
下面是使用 tkinter 的 python 中的注册表单的完整代码片段。该程序仅在用户界面方面不依赖于完整的代码。
from tkinter import *
ws = Tk()
ws.title('PythonGuides')
ws.config(bg='#0B5A81')
f = ('Times', 14)
var = StringVar()
var.set('male')
countries = []
variable = StringVar()
world = open('countries.txt', 'r')
for country in world:
country = country.rstrip('\n')
countries.append(country)
variable.set(countries[22])
right_frame = Frame(
ws,
bd=2,
bg='#CCCCCC',
relief=SOLID,
padx=10,
pady=10
)
Label(
right_frame,
text="Enter Name",
bg='#CCCCCC',
font=f
).grid(row=0, column=0, sticky=W, pady=10)
Label(
right_frame,
text="Enter Email",
bg='#CCCCCC',
font=f
).grid(row=1, column=0, sticky=W, pady=10)
Label(
right_frame,
text="Contact Number",
bg='#CCCCCC',
font=f
).grid(row=2, column=0, sticky=W, pady=10)
Label(
right_frame,
text="Select Gender",
bg='#CCCCCC',
font=f
).grid(row=3, column=0, sticky=W, pady=10)
Label(
right_frame,
text="Select Country",
bg='#CCCCCC',
font=f
).grid(row=4, column=0, sticky=W, pady=10)
Label(
right_frame,
text="Enter Password",
bg='#CCCCCC',
font=f
).grid(row=5, column=0, sticky=W, pady=10)
Label(
right_frame,
text="Re-Enter Password",
bg='#CCCCCC',
font=f
).grid(row=6, column=0, sticky=W, pady=10)
gender_frame = LabelFrame(
right_frame,
bg='#CCCCCC',
padx=10,
pady=10,
)
register_name = Entry(
right_frame,
font=f
)
register_email = Entry(
right_frame,
font=f
)
register_mobile = Entry(
right_frame,
font=f
)
male_rb = Radiobutton(
gender_frame,
text='Male',
bg='#CCCCCC',
variable=var,
value='male',
font=('Times', 10),
)
female_rb = Radiobutton(
gender_frame,
text='Female',
bg='#CCCCCC',
variable=var,
value='female',
font=('Times', 10),
)
others_rb = Radiobutton(
gender_frame,
text='Others',
bg='#CCCCCC',
variable=var,
value='others',
font=('Times', 10)
)
register_country = OptionMenu(
right_frame,
variable,
*countries)
register_country.config(
width=15,
font=('Times', 12)
)
register_pwd = Entry(
right_frame,
font=f,
show='*'
)
pwd_again = Entry(
right_frame,
font=f,
show='*'
)
register_btn = Button(
right_frame,
width=15,
text='Register',
font=f,
relief=SOLID,
cursor='hand2',
command=None
)
register_name.grid(row=0, column=1, pady=10, padx=20)
register_email.grid(row=1, column=1, pady=10, padx=20)
register_mobile.grid(row=2, column=1, pady=10, padx=20)
register_country.grid(row=4, column=1, pady=10, padx=20)
register_pwd.grid(row=5, column=1, pady=10, padx=20)
pwd_again.grid(row=6, column=1, pady=10, padx=20)
register_btn.grid(row=7, column=1, pady=10, padx=20)
right_frame.pack()
gender_frame.grid(row=3, column=1, pady=10, padx=20)
male_rb.pack(expand=True, side=LEFT)
female_rb.pack(expand=True, side=LEFT)
others_rb.pack(expand=True, side=LEFT)
ws.mainloop()
输出:
在这个输出中，您可以看到注册表单是使用 Python Tkinter 创建的。该表单具有使用 Python Tkinter 小部件创建的输入和选择字段。
registration form using tkinter
使用数据库在 Python Tkinter 中登录页面
本节将看到 python tkinter 中的登录页面的代码解释，该页面带有数据库。完整的应用程序代码共享在页面的末尾。本节中显示的代码仅在用户界面方面是完整的。
Python Tkinter 中的框架小部件
Framewidget 允许在上面放置其他 widget。如果框架上放置了其他小部件，应用程序外观会进行组织，并且它还可以控制各个部分。- 这里
left_frame用于创建应用程序的登录部分。 - Frame 关键字用于调用 frame widget，它被放置在主窗口上，即
ws。 bd是 Python Tkinter 中框架小部件的边框宽度- 浮雕有不同的模式，由我们用过的立体，它勾勒出轮廓。在相框周围。
left_frame = Frame(
ws,
bd=2,
bg='#CCCCCC',
relief=SOLID,
padx=10,
pady=10
)
Python Tkinter 中的标签小部件
- 标签用于向应用程序添加文本。
- 在下面的代码中，Label 是用于创建标签小部件的关键字。
- 我们将这个标签放在左帧上。
- 此处添加的任何文本将显示在应用程序上
- 我们使用网格作为几何方法来定位文本。
Label(
left_frame,
text="Enter Email",
bg='#CCCCCC',
font=f).grid(row=0, column=0, sticky=W, pady=10)
Python Tkinter 中的入口小部件
- 条目小部件用于接收用户的输入。它提供了一个空白空间，用户可以在其中键入任何文本。
- Entry 关键字用于所有的调用入口小部件，它被放置在
left_frame上 - 我们使用网格作为几何方法来定位文本。
email_tf = Entry(
left_frame,
font=f
)
email_tf.grid(row=0, column=1, pady=10, padx=20)
Python Tkinter 中的按钮部件
- Python Tkinter 中的按钮用于触发活动。当它被点击时应该会发生一些事情。
- 在这个应用程序中，按钮用于保存数据库中的数据。
- Button 关键字用于创建一个小部件，它被放置在
left_frame中。 - 宽度是按钮的左右间距
- 文本是按钮上显示的名称。
- 光标是鼠标指针的图标。我们使用了 hand2，这意味着每当用户将光标放在按钮上时，光标就会变成一个指向的手指。
- 命令保存了关于点击按钮会发生什么的信息。这里我们将它设置为 None，这意味着什么都不会发生，但是在完整的代码中，我们为它提供了一个函数名。
login_btn = Button(
left_frame,
width=15,
text='Login',
font=f,
relief=SOLID,
cursor='hand2',
command=None
)
login_btn.grid(row=2, column=1, pady=10, padx=20)
登录的完整代码片段:
下面是使用 Python Tkinter 的登录表单的完整代码片段。该程序仅在用户界面方面不依赖于完整的代码。
from tkinter import *
ws = Tk()
ws.title('PythonGuides')
ws.config(bg='#0B5A81')
f = ('Times', 14)
left_frame = Frame(
ws,
bd=2,
bg='#CCCCCC',
relief=SOLID,
padx=10,
pady=10
)
Label(
left_frame,
text="Enter Email",
bg='#CCCCCC',
font=f).grid(row=0, column=0, sticky=W, pady=10)
Label(
left_frame,
text="Enter Password",
bg='#CCCCCC',
font=f
).grid(row=1, column=0, pady=10)
email_tf = Entry(
left_frame,
font=f
)
pwd_tf = Entry(
left_frame,
font=f,
show='*'
)
login_btn = Button(
left_frame,
width=15,
text='Login',
font=f,
relief=SOLID,
cursor='hand2',
command=None
)
email_tf.grid(row=0, column=1, pady=10, padx=20)
pwd_tf.grid(row=1, column=1, pady=10, padx=20)
login_btn.grid(row=2, column=1, pady=10, padx=20)
left_frame.pack()
ws.mainloop()
输出:
在这个输出中，您可以看到一个使用 Python Tkinter 创建的登录表单。
simple login form in python
这是 python tkinter 中带有数据库的登录页面的样子。
对空字段使用 tkinter 验证的登记表
- 在本节中，我们将看到用于识别 Python Tkinter 注册表中的空字段的代码，我们将看到如何强制用户在相应的文本字段或选择字段(如 Radiobutton 和 OptionMenu)中提供输入。
- 我们使用了一个简单的策略来做到这一点。我们检查每个输入字段，并且每当用户提供输入时，我们就将 check_counter 变量加 1。
- 我们有了条目字段总数，现在我们用字段总数检查 check_count。如果它们相等，那么应用程序将继续并保存数据，否则它将为相应的空字段抛出一条错误消息。
- 应用程序中使用的另一个验证是密码验证。因为我们在注册表中有两个密码字段。
- 输入口令
- 呈现密码
- 我们已经把这两个进行了比较。如果两者相同，应用程序将继续运行，否则将抛出相关的错误消息。
代码片段:
下面是用于在 python 中验证注册表中的条目字段的代码。
check_counter=0
warn = ""
if register_name.get() == "":
warn = "Name can't be empty"
else:
check_counter += 1
check_counter=0
if register_email.get() == "":
warn = "Email can't be empty"
else:
check_counter += 1
if register_mobile.get() == "":
warn = "Contact can't be empty"
else:
check_counter += 1
if var.get() == "":
warn = "Select Gender"
else:
check_counter += 1
if variable.get() == "":
warn = "Select Country"
else:
check_counter += 1
if register_pwd.get() == "":
warn = "Password can't be empty"
else:
check_counter += 1
if pwd_again.get() == "":
warn = "Re-enter password can't be empty"
else:
check_counter += 1
输出:
在这个输出中，用户试图在不提供联系号码的情况下注册，因此他收到了一个错误提示，上面提到了错误。如果用户试图跳过任何其他字段，也会发生同样的事情。
registration form in python using tkinter (validation for empty fields)
代码片段:
下面是密码不匹配验证的代码片段。
if register_pwd.get() != pwd_again.get():
warn = "Passwords didn't match!"
else:
check_counter += 1
输出:
下面是显示密码不匹配时提示的错误的输出。
registration form in python using tkinter (password validation)
这就是我们如何使用 tkinter 在注册表中实现验证。
将 Python Tkinter 注册表单数据保存到 sqlite3
正如我们所知，这是一个使用 Tkinter 和数据库在 python 中注册表单的例子，在这个应用程序中，我们使用 SQLite3 在数据库中存储数据。SQLite3 预装了 python，你需要做的就是 import sqlite3。要访问数据库中的数据，您可以使用 DB 浏览器。
使用 Python Tkinter 中的 SQLite 创建数据库
这行代码将创建一个名为 userdata.db 的数据库。该文件将存储在主文件所在的位置。使用数据库浏览器，您可以查看和编辑数据。
con = sqlite3.connect('userdata.db')
使用下面的代码，你可以为数据库创建表格。
con = sqlite3.connect('userdata.db')
cur = con.cursor()
cur.execute('''CREATE TABLE IF NOT EXISTS record(
name text,
email text,
contact number,
gender text,
country text,
password text
)
''')
con.commit()
在 Python Tkinter 中使用 SQLite 插入数据
- 一旦我们创建了数据库，现在重要的是连接到数据库中插入数据。
cur.execute()用于传递插入查询。我们使用了字典格式传递查询。con.commit()写下数据库中的变化。
con = sqlite3.connect('userdata.db')
cur = con.cursor()
cur.execute("INSERT INTO record VALUES (:name, :email, :contact, :gender, :country, :password)", {
'name': register_name.get(),
'email': register_email.get(),
'contact': register_mobile.get(),
'gender': var.get(),
'country': variable.get(),
'password': register_pwd.get()
})
con.commit()
这是记录的输出，这是数据库浏览器软件的界面。
registration form in python using tkinter with database
完整代码片段:
这里是使用 Python Tkinter 创建的应用程序的完整代码。我们已经在上面部分解释了整个代码。
from tkinter import *
from tkinter import messagebox
import sqlite3
f = ('Times', 14)
con = sqlite3.connect('userdata.db')
cur = con.cursor()
cur.execute('''CREATE TABLE IF NOT EXISTS record(
name text,
email text,
contact number,
gender text,
country text,
password text
)
''')
con.commit()
ws = Tk()
ws.title('PythonGuides')
ws.geometry('940x500')
ws.config(bg='#0B5A81')
def insert_record():
check_counter=0
warn = ""
if register_name.get() == "":
warn = "Name can't be empty"
else:
check_counter += 1
if register_email.get() == "":
warn = "Email can't be empty"
else:
check_counter += 1
if register_mobile.get() == "":
warn = "Contact can't be empty"
else:
check_counter += 1
if var.get() == "":
warn = "Select Gender"
else:
check_counter += 1
if variable.get() == "":
warn = "Select Country"
else:
check_counter += 1
if register_pwd.get() == "":
warn = "Password can't be empty"
else:
check_counter += 1
if pwd_again.get() == "":
warn = "Re-enter password can't be empty"
else:
check_counter += 1
if register_pwd.get() != pwd_again.get():
warn = "Passwords didn't match!"
else:
check_counter += 1
if check_counter == 8:
try:
con = sqlite3.connect('userdata.db')
cur = con.cursor()
cur.execute("INSERT INTO record VALUES (:name, :email, :contact, :gender, :country, :password)", {
'name': register_name.get(),
'email': register_email.get(),
'contact': register_mobile.get(),
'gender': var.get(),
'country': variable.get(),
'password': register_pwd.get()
})
con.commit()
messagebox.showinfo('confirmation', 'Record Saved')
except Exception as ep:
messagebox.showerror('', ep)
else:
messagebox.showerror('Error', warn)
def login_response():
try:
con = sqlite3.connect('userdata.db')
c = con.cursor()
for row in c.execute("Select * from record"):
username = row[1]
pwd = row[5]
except Exception as ep:
messagebox.showerror('', ep)
uname = email_tf.get()
upwd = pwd_tf.get()
check_counter=0
if uname == "":
warn = "Username can't be empty"
else:
check_counter += 1
if upwd == "":
warn = "Password can't be empty"
else:
check_counter += 1
if check_counter == 2:
if (uname == username and upwd == pwd):
messagebox.showinfo('Login Status', 'Logged in Successfully!')
else:
messagebox.showerror('Login Status', 'invalid username or password')
else:
messagebox.showerror('', warn)
var = StringVar()
var.set('male')
countries = []
variable = StringVar()
world = open('countries.txt', 'r')
for country in world:
country = country.rstrip('\n')
countries.append(country)
variable.set(countries[22])
# widgets
left_frame = Frame(
ws,
bd=2,
bg='#CCCCCC',
relief=SOLID,
padx=10,
pady=10
)
Label(
left_frame,
text="Enter Email",
bg='#CCCCCC',
font=f).grid(row=0, column=0, sticky=W, pady=10)
Label(
left_frame,
text="Enter Password",
bg='#CCCCCC',
font=f
).grid(row=1, column=0, pady=10)
email_tf = Entry(
left_frame,
font=f
)
pwd_tf = Entry(
left_frame,
font=f,
show='*'
)
login_btn = Button(
left_frame,
width=15,
text='Login',
font=f,
relief=SOLID,
cursor='hand2',
command=login_response
)
right_frame = Frame(
ws,
bd=2,
bg='#CCCCCC',
relief=SOLID,
padx=10,
pady=10
)
Label(
right_frame,
text="Enter Name",
bg='#CCCCCC',
font=f
).grid(row=0, column=0, sticky=W, pady=10)
Label(
right_frame,
text="Enter Email",
bg='#CCCCCC',
font=f
).grid(row=1, column=0, sticky=W, pady=10)
Label(
right_frame,
text="Contact Number",
bg='#CCCCCC',
font=f
).grid(row=2, column=0, sticky=W, pady=10)
Label(
right_frame,
text="Select Gender",
bg='#CCCCCC',
font=f
).grid(row=3, column=0, sticky=W, pady=10)
Label(
right_frame,
text="Select Country",
bg='#CCCCCC',
font=f
).grid(row=4, column=0, sticky=W, pady=10)
Label(
right_frame,
text="Enter Password",
bg='#CCCCCC',
font=f
).grid(row=5, column=0, sticky=W, pady=10)
Label(
right_frame,
text="Re-Enter Password",
bg='#CCCCCC',
font=f
).grid(row=6, column=0, sticky=W, pady=10)
gender_frame = LabelFrame(
right_frame,
bg='#CCCCCC',
padx=10,
pady=10,
)
register_name = Entry(
right_frame,
font=f
)
register_email = Entry(
right_frame,
font=f
)
register_mobile = Entry(
right_frame,
font=f
)
male_rb = Radiobutton(
gender_frame,
text='Male',
bg='#CCCCCC',
variable=var,
value='male',
font=('Times', 10),
)
female_rb = Radiobutton(
gender_frame,
text='Female',
bg='#CCCCCC',
variable=var,
value='female',
font=('Times', 10),
)
others_rb = Radiobutton(
gender_frame,
text='Others',
bg='#CCCCCC',
variable=var,
value='others',
font=('Times', 10)
)
register_country = OptionMenu(
right_frame,
variable,
*countries)
register_country.config(
width=15,
font=('Times', 12)
)
register_pwd = Entry(
right_frame,
font=f,
show='*'
)
pwd_again = Entry(
right_frame,
font=f,
show='*'
)
register_btn = Button(
right_frame,
width=15,
text='Register',
font=f,
relief=SOLID,
cursor='hand2',
command=insert_record
)
# widgets placement
email_tf.grid(row=0, column=1, pady=10, padx=20)
pwd_tf.grid(row=1, column=1, pady=10, padx=20)
login_btn.grid(row=2, column=1, pady=10, padx=20)
left_frame.place(x=50, y=50)
register_name.grid(row=0, column=1, pady=10, padx=20)
register_email.grid(row=1, column=1, pady=10, padx=20)
register_mobile.grid(row=2, column=1, pady=10, padx=20)
register_country.grid(row=4, column=1, pady=10, padx=20)
register_pwd.grid(row=5, column=1, pady=10, padx=20)
pwd_again.grid(row=6, column=1, pady=10, padx=20)
register_btn.grid(row=7, column=1, pady=10, padx=20)
right_frame.place(x=500, y=50)
gender_frame.grid(row=3, column=1, pady=10, padx=20)
male_rb.pack(expand=True, side=LEFT)
female_rb.pack(expand=True, side=LEFT)
others_rb.pack(expand=True, side=LEFT)
# infinite loop
ws.mainloop()
输出:
在这个输出中，您可以看到主应用程序的界面。我们在左边有一个登录屏幕，在右边有一个注册屏幕。必须在登录和注册屏幕上提供所有信息。
Fig 1: Main Application Window
在这个屏幕中，试图登录的用户没有注册，这就是她看到这个错误消息的原因。如果注册用户输入了错误的凭证，也会出现同样的错误。
Fig 2: Login failed
这是验证错误，用户试图在没有填写所有字段的情况下登录。
Fig 3: Fields can’t be empty
这是另一个验证错误，重要的是密码和重新输入的密码相同。
Fig 4: Password match failed
在此输出中，用户提供了与重新输入密码列匹配的所有信息和密码。用户向应用程序注册。
Fig 5: Registration Successful
在这个输出中，您可以看到已经注册的用户可以通过提供正确的凭证来登录..
Fig 6: Login Successful
下面你可以看到，用 python 编写的注册表使用 tkinter 数据已经保存到了 sqlite3 数据库中。
Fig 7:
您可能还喜欢:
- 从 PDF Python 中提取文本
- 使用 Python Tkinter 的身体质量指数计算器
- 如何使用 Python Tkinter 创建倒计时定时器
- 用 Python Tkinter 上传文件
- 如何使用 Python Tkinter 创建日期时间选择器
我希望你一定喜欢 python Tkinter 示例中完整的登录和注册表单，自己试试代码。它解决了以下问题:
- 带有数据库的 python 注册表
- 使用 tkinter 和数据库在 python 中注册表单
- 使用 tkinter 在 python 中注册表单
- python 注册表单代码 tkinter
- 使用数据库 sqlite3 在 python tkinter 中登录页面
- python 中的简单登录表单
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Python 中的正则表达式
想了解一下 Python 中的正则表达式？在这个 python 教程中我们将讨论:
- Python 中的正则表达式
- Python 中正则表达式的功能
- Python 正则表达式特殊序列
- Python 正则表达式函数
- 搜索功能()
- 分割函数()
- findall 函数()
- 子函数()
- Python 验证示例(使用正则表达式)
- Python 密码字段验证
- Python 中的手机号码字段验证
- Python 中的电子邮件字段验证
- Python 邮政编码字段验证
- Python 中的 URL 字段验证
目录
Python 中的正则表达式
正则表达式或者也称为正则表达式模式帮助我们使用各种模式来查找或匹配。在 Python 中，我们可以通过导入 re 模块来使用正则表达式，如下所示:
要在 Python 中导入 re 模块，可以使用下面的系统。
import re
Python 中正则表达式的功能
re 模块有一些您可以使用的功能:
search():该函数从字符串中返回匹配对象split():这个函数将给定的字符串拆分成列表find all():该函数返回字符串中的所有匹配项sub():此函数替换字符串中的任何匹配项
Python 正则表达式特殊序列
这里有几个 Python 正则表达式特殊序列，它们是基于功能的字符。
| 特殊序列 |
| \ A-这将返回在字符串的开头的指定字符的匹配。 |
| \ Z–返回位于字符串末端的指定字符的匹配。 |
| \ b–返回位于字符串开头或结尾的指定字符的匹配。 |
| \ B–返回不在字符串开头或结尾的指定字符的匹配。 |
| \ d–如果字符串中出现数字，则返回一个匹配。 |
| \ D–如果字符串中的数字不是，则返回一个匹配。 |
| \ s–当字符中包含空格时，返回一个匹配。 |
| \ S–当字符中不包含空格时，返回一个匹配。 |
| \ w–当字符串中包含单词字符时，返回一个匹配项。 |
| \ W–当字符串中不包含单词字符时，返回一个匹配。 |
Python 正则表达式函数
现在，让我们看看几个可以和 Python 正则表达式一起使用的 Python 函数。
搜索功能()
现在我们可以看到如何在 python 中的正则表达式中执行搜索功能。
在这个例子中，我已经导入了一个模块 re 并指定了一个字符串为“芒果是黄色的” re.search ()函数用于从字符串中返回匹配对象。
'\Amango' 返回开头的字符。使用 '\zstring' 返回末尾的字符。
示例:
import re
string = "Mango is yellow"
match = re.search('\AMango', string)
if match:
print("pattern found")
else:
print("pattern not found")
下图显示了输出:
Python search function()
分割函数()
现在我们可以看到如何在 python 中执行正则表达式的 split function()
在这个例子中，我导入了一个重新打包， re.split(pattern，a) 这个函数在匹配的地方拆分字符串，并返回发生拆分的字符串列表。
示例:
import re
a = 'mango 4 is yellow.'
pattern = '\d'
res = re.split(pattern, a)
print(res)
下图显示了输出:
Python split function()
findall 函数()
现在我们可以看到如何在 python 中执行正则表达式的 findall()
在本例中，我采用了一个既有字符又有数字的字符串， re.findall() 函数查找所有匹配项，并返回一个匹配项列表作为字符串 '\d+' 这将返回字符串中的数字。
示例:
import re
a = 'mango 24 is 12 yellow 6'
pattern = '\d+'
res = re.findall(pattern, a)
print(res)
下图显示了输出:
findall function()
子函数()
现在我们可以看到如何在 python 中执行正则表达式的 sub function()
在这个例子中，我替换了字符串之间的空格， re.sub() 函数用另一个子字符串替换特定子字符串的出现。
示例:
import re
string = 'I am having silver color car'
pattern = '\s'
replace = ''
newstring = re.sub(pattern, replace, string)
print(newstring)
下图显示了输出:
sub function()
读取: Python NumPy 连接和 Python NumPy 读取 CSV
Python 验证示例(使用正则表达式)
让我们看看几个使用 Python 正则表达式的 Python 验证示例。
Python 密码域验证
现在，让我们看看如何在 Python 中验证密码字段。
验证:
- [a-z]之间至少有一个字母
- [A-Z]之间至少有一个字母
- 至少一个介于[0-9]之间的数字
- 至少包含[$#@]中的一个字符
现在，在这个概念中，我们可以看到如何使用 python 中的正则表达式来验证密码。
在本例中，我认为密码的长度应该大于 6 或小于 11，并且密码应该包含一个介于[a-z]之间的字母、一个介于[A-Z]之间的字母、一个介于[0-9]之间的数字和一个来自[$#@]的字符，如果条件有效，它应该打印“有效密码”，否则打印“无效密码”。
举例:
import re
a= input("enter your password")
x = True
while x:
if (len(a)<6 or len(a)>11):
break
elif not re.search("[a-z]",a):
break
elif not re.search("[0-9]",a):
break
elif not re.search("[A-Z]",a):
break
elif not re.search("[$#@]",a):
break
elif re.search("\s",a):
break
else:
print("Valid Password")
x=False
break
if x:
print("Not a Valid Password")
下图显示了输出:
Password field validation
Python 中的手机号码字段验证
现在我们可以看到如何使用 python 中的正则表达式来验证手机号码。
- 起始数字应该是(0/91)
- 第一个数字应该在[7-9]之间
- 接下来的 9 个数字应该在[0-9]之间
在这个例子中，我将模式“9945555555”作为手机号码，将验证作为
("(0/91)?[7-9][0-9]{9}")
举例:
import re
def isValid(p):
Pattern = re.compile("(0/91)?[7-9][0-9]{9}")
return Pattern.match(p)
p = "9945555555"
if (isValid(p)):
print ("Valid Number")
else :
print ("Invalid Number")
通过这种方式，您可以在 Python 中验证手机号码字段有效性。
阅读: Python NumPy 日志
Python 中的电子邮件字段验证
现在我们可以看到如何使用 python 中的正则表达式来验证电子邮件
在这个例子中，我有一个输入字符串，验证格式是 [A-Za-z0-9-]+(。[A-Za-z0-9-]+)@[A-Za-z0-9-]+(。[A-Za-z0-9]+)(。【A-Za-z】{ 2，}) 。IGNORECASE 允许在常规表达式中区分大小写匹配。 re.match ()将搜索正则表达式模式并返回字符串列表。
示例:
import re
email = input ("Please type in an email address ")
if re.match("\A(?P<name>[\w\-_]+)@(?P<domain>[\w\-_]+).(?P<toplevel>[\w]+)\Z",email,re.IGNORECASE):
print("email is valid")
else:
print("email is invalid")
验证的详细格式
[A-Za-z0-9-_]+(.[A-Za-z0-9-_]+)*@[A-Za-z0-9-]+(.[A-Za-z0-9]+)*(.[A-Za-z]{2,})
下图显示了输出:
Email field validation
Python 邮政编码字段验证
现在我们可以看到如何使用 python 中的正则表达式来验证 zipcode
在这个例子中，我们可以看到如何验证一个邮政编码，re.match() 将搜索正则表达式模式并返回字符串列表， re.findall()将搜索字符串中的所有模式。
- \d :匹配并捕获列表中的一个数字
- ？= :前一项是可选的，几乎匹配一次
- \1 :被捕获组的反向引用
- < 2 :尾数应该小于真
示例:
import re
a=input('enter a zipcode')
b = (re.match(r'^[1-9][\d]{5}$',a) and len(re.findall(r'(\d)(?=\d\1)',a))<2 )
print(b)
下图显示了 Python 邮政编码验证的输出。
Zip-code field validation
Python 中的 URL 字段验证
这里我们可以看到如何使用 python 中的正则表达式来验证 URL
在这个例子中，我采用了验证格式，因为 url 必须以(http 或 https)开头，接下来它应该有://和 www。然后是长度{2，150}，最后是域名。com ，。组织
示例:
import re
def isValidURL(string):
regex = ("((http|https)://)(www.)?" +"[a-zA-Z0-9@:%._\\+~#?&//=]" +"{2,150}\\.[a-z]" +"{2,6}\\b([-a-zA-Z0-9@:%" +"._\\+~#?//&=]*)")
a = re.compile(regex)
if (string == None):
return False
if(re.search(a, string)):
return True
else:
return False
url = "https://pythonguides.com"
if(isValidURL(url) == True):
print("valid URL")
else:
print("Not valid URL")
下图显示了输出:
URL field validation
您可能会喜欢以下 Python 教程:
- Python 布尔函数
- Python 打印 2 位小数
- Python 生成器
- Python Tkinter 单选按钮–如何使用
- Python 格式数字加逗号
- Python 生成随机数和字符串
- Python 将列表写入文件，并附有示例
- Python 线程和多线程
- 如何将 Python 角度转换为弧度
- Python 比较运算符
- 集合的并集 Python +实例
我希望本教程有助于学习 python 中的正则表达式，涵盖以下主题。
- Python 中的正则表达式
- Python 中正则表达式的功能
- Python 正则表达式特殊序列
- Python 正则表达式函数
- 搜索功能()
- 分割函数()
- findall 函数()
- 子函数()
- Python 验证示例(使用正则表达式)
- Python 密码字段验证
- Python 中的手机号码字段验证
- Python 中的电子邮件字段验证
- Python 邮政编码字段验证
- Python 中的 URL 字段验证
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
