一、安装与运行
1、conda是一个开源包管理工具，可用于安装、运行各种软件包。安装conda之后，可以通过conda install命令来安装Torch。
conda install pytorch torchvision torchaudio -c pytorch
2、可以通过conda创建虚拟环境并安装Torch，以避免系统中存在多个Torch版本的问题。
conda create -n myenv python=3.8
conda activate myenv
conda install pytorch torchvision torchaudio -c pytorch
二、Torch的基础操作
1、Tensor是Torch中的核心数据结构，可以理解为多维数组。可以通过Tensor创建零向量、随机向量和手动设置向量等操作。
#创建一个2x3的零向量
import torch
x = torch.zeros(2, 3)
print(x)
#创建一个2x3的随机向量
x = torch.randn(2, 3)
print(x)
#创建一个2x3的手动设置向量
x = torch.tensor([[1,2,3],[4,5,6]])
print(x)
2、可以通过Tensor进行数学运算，如加减乘除和矩阵乘法等操作。
x = torch.randn(2, 3)
y = torch.randn(2, 3)
#加
z = x + y
#减
z = x - y
#乘
z = x * y
#除
z = x / y
#矩阵乘法
x = torch.rand(2, 3)
y = torch.rand(3, 2)
z = torch.mm(x, y) # z的大小是(2,2)
print(z)
三、使用Torch进行深度学习
1、Torch的神经网络包nn可以帮助构建神经网络模型。可以通过nn包中的内置模块实现卷积神经网络(CNN)和长短时记忆网络(LSTM)等模型。
import torch.nn as nn
#构建简单的神经网络模型
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc1 = nn.Linear(784, 256)
self.fc2 = nn.Linear(256, 128)
self.fc3 = nn.Linear(128, 10)
def forward(self, x):
x = x.view(x.size(0), -1)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
#构建CNN模型
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, kernel_size=5, padding=2)
self.conv2 = nn.Conv2d(32, 64, kernel_size=5, padding=2)
self.fc1 = nn.Linear(64*7*7, 1024)
self.fc2 = nn.Linear(1024, 10)
def forward(self, x):
x = F.relu(self.conv1(x))
x = F.max_pool2d(x, 2)
x = F.relu(self.conv2(x))
x = F.max_pool2d(x, 2)
x = x.view(x.size(0), -1)
x = F.relu(self.fc1(x))
x = self.fc2(x)
return x
#构建LSTM模型
class LSTM(nn.Module):
def __init__(self):
super(LSTM, self).__init__()
self.lstm = nn.LSTM(256, 512, num_layers=3, batch_first=True)
self.fc = nn.Linear(512, 10)
def forward(self, x):
h0 = torch.zeros(3, x.size(0), 512)
c0 = torch.zeros(3, x.size(0), 512)
out, _ = self.lstm(x, (h0,c0))
out = F.softmax(self.fc(out[:, -1, :]), dim=1)
return out
2、可以使用Torch进行图像分类、目标检测和自然语言处理等各种深度学习任务。
import torch.optim as optim
#在MNIST数据集上训练CNN模型
import torchvision.datasets as dsets
import torchvision.transforms as transforms
from torch.autograd import Variable
#加载MNIST数据集
train_dataset = dsets.MNIST(root='./data', train=True, transform=transforms.ToTensor(), download=True)
test_dataset = dsets.MNIST(root='./data', train=False, transform=transforms.ToTensor(),download=True)
#加载数据集并转换为Tensor格式
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)
#初始化模型、损失函数和优化器
net = Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=learning_rate, momentum=0.9)
#训练模型
for epoch in range(num_epochs):
for i, (images, labels) in enumerate(train_loader):
images = Variable(images)
labels = Variable(labels)
optimizer.zero_grad()
outputs = net(images)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
#在CIFAR-10数据集上训练ResNet模型
from torchvision import models
from torchsummary import summary
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
#加载CIFAR-10数据集
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True, num_workers=2)
testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)
testloader = torch.utils.data.DataLoader(testset, batch_size=100, shuffle=False, num_workers=2)
#设置ResNet18模型
net = models.resnet18(pretrained=False)
num_ftrs = net.fc.in_features
net.fc = nn.Linear(num_ftrs, 10)
net.to(device)
#训练模型
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=200)
for epoch in range(num_epochs):
net.train()
train_loss = 0
for batch_idx, (inputs, targets) in enumerate(trainloader):
inputs, targets = inputs.to(device), targets.to(device)
outputs = net(inputs)
loss = criterion(outputs, targets)
optimizer.zero_grad()
loss.backward()
optimizer.step()
scheduler.step()
四、Torch的应用场景
1、深度学习研究及开发
import torch.nn as nn
import torch.optim as optim
import torch.utils.data as data
from torch.autograd import Variable
import torchvision.datasets as dsets
#加载数据集
train_dataset = dsets.MNIST(root='./data', train=True, transform=transforms.ToTensor(), download=True)
test_dataset = dsets.MNIST(root='./data', train=False, transform=transforms.ToTensor(),download=True)
#初始化模型、损失函数和优化器
net = Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
#训练模型
for epoch in range(2):
for i, (images, labels) in enumerate(train_loader):
images = Variable(images)
labels = Variable(labels)
optimizer.zero_grad()
outputs = net(images)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
#使用Torch进行分布式训练
import torch.distributed as dist
import torch.multiprocessing as mp
from torch.nn.parallel import DistributedDataParallel as DDP
def train(model, device, train_loader, criterion, optimizer, epoch):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
output = model(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()
def setup(rank, world_size):
os.environ['MASTER_ADDR'] = 'localhost'
os.environ['MASTER_PORT'] = '12345'
# initialize the process group
dist.init_process_group("gloo", rank=rank, world_size=world_size)
def cleanup():
dist.destroy_process_group()
if __name__ == '__main__':
MP = False
rank, world_size = 0, 1
if MP:
mp.set_start_method("spawn")
world_size = mp.cpu_count()
rank = args.nr * args.gpus + i
setup(rank, world_size)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = Net().to(device)
if MP:
model = DDP(model, device_ids=[i], output_device=i)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
train_loader = torch.utils.data.DataLoader(, batch_size=64, shuffle=True, num_workers=0, pin_memory=True)
for epoch in range(2):
train(model, device, train_loader, criterion, optimizer, epoch)
if MP:
cleanup()
2、机器学习算法实现
import torch
import pandas as pd
#基于线性回归算法实现房价预测
from torch.utils.data import Dataset, DataLoader
class HousingDataset(Dataset):
def __init__(self):
#使用pandas读取数据集，并将其转换为Tensor格式
train_data = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/housing/housing.data', header=None, sep='\s+').values
self.len = train_data.shape[0]
self.x_data = torch.from_numpy(train_data[:, :-1]).float()
self.y_data = torch.from_numpy(train_data[:, -1].reshape(-1,1)).float()
def __getitem__(self, index):
return self.x_data[index], self.y_data[index]
def __len__(self):
return self.len
dataset = HousingDataset()
train_loader = DataLoader(dataset=dataset, batch_size=32, shuffle=True)
class LinearRegression(torch.nn.Module):
def __init__(self):
super(LinearRegression, self).__init__()
self.linear = torch.nn.Linear(13, 1)
def forward(self, x):
y_pred = self.linear(x)
return y_pred
model = LinearRegression()
criterion = torch.nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
epochs = 1000
for epoch in range(epochs):
for x, y in train_loader:
y_pred = model(x)
loss = criterion(y_pred, y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if epoch % 100 == 0:
print('epoch {}, loss {}'.format(epoch, loss.item()))
五、总结
本文从安装与运行、Torch的基础操作、使用Torch进行深度学习、Torch的应用场景等多个方面详细阐述了conda torch。通过掌握本文所述的知识，可以熟练使用Torch进行深度学习、机器学习算法实现等各种任务。
原创文章，作者：DJWZX，如若转载，请注明出处：https://www.506064.com/n/334486.html
微信扫一扫 
支付宝扫一扫 