公众微信网站建设,织梦如何做视频网站,个人网站设计论文下载,建筑网站建设案例2019 年#xff0c;ML 框架之争只剩两个实力玩家#xff1a;PyTorch 和 TensorFlow。研究者大批涌向 PyTorch#xff0c;而业界的首选仍然是 TensorFlow。Pytorch和TensorFlow的区别#xff1a;TensorFlow是基于静态计算图的#xff0c;静态计算图是先定义后运行#xff… 2019 年ML 框架之争只剩两个实力玩家PyTorch 和 TensorFlow。研究者大批涌向 PyTorch而业界的首选仍然是 TensorFlow。Pytorch和TensorFlow的区别TensorFlow是基于静态计算图的静态计算图是先定义后运行一次定义多次运行(Tensorflow 2.0也开始使用动态计算图)PyTorch是基于动态图的是在运行的过程中被定义的在运行的时候构建可以多次构建多次运行PyTorch的特点简单。PyTorch 与 numpy 类似可以很容易地与 Python 生态系统融合。例如向 PyTorch 模型的任意位置放入一个 pdb 断点它都可以正常工作。而在 TensorFlow 中调试模型需要一个激活的会话最后会变得非常棘手。优秀的 API。比起 TensorFlow 的 API多数研究者更喜欢 PyTorch 的 API。部分原因在于 PyTorch 的设计更加合理还有一部分原因在于。TensorFlow 在将 API 转换多次之后已经自损元气。性能。尽管 PyTorch 的动态图留给优化的机会非常之少但有不少非正式报告称 PyTorch 与 TensorFlow 一样快。目前还不清楚这是不是真的但至少TensorFlow 在这方面还没有取得决定性优势。本文推荐一个简单的Pytorch的入门学习教程(来源于网络如有问题请及时联系)张量 Pytorch中的Tensor和ndarray类似区别在于ndarray不能再GPU上加速而Tensor可以使用GPU加速。构建一个未初始化3*3的矩阵import torchx torch.empty(3,3)# tensor([[1.0469e-38, 5.9694e-39, 8.9082e-39],# [1.0194e-38, 9.1837e-39, 4.6837e-39],# [9.9184e-39, 9.0000e-39, 1.0561e-38]])构建一个3*3的随机矩阵x torch.rand(3, 3)# tensor([[0.4289, 0.6872, 0.2781],# [0.2129, 0.7520, 0.3994],# [0.0995, 0.9080, 0.7868]])dtype long的全零矩阵x torch.zeros(5, 3, dtypetorch.long)# tensor([[0, 0, 0],# [0, 0, 0],# [0, 0, 0]])把数据[5.5, 3]变成Tensorx torch.tensor([5.5, 3])# tensor([5.5000, 3.0000])得到数组的shapeprint(x.size())# torch.Size([2])torch.Size 实际上是一个元组因此它支持所有元组操作。Operation操作加法import torch# ------------- 方法一 -------------#x torch.rand(2, 2) # 构建一个(2,2)的随机数组y torch.rand(2, 2) # 构建一个(2,2)的随机数组print(x y)# ------------- 方法二 -------------#print(torch.add(x, y))# ------------- 方法三 -------------#result torch.empty(2, 2)torch.add(x, y, outresult)print(result)# ------------- 方法四 -------------## 把x加到y上y.add_(x)print(y)# 所有的结果都等于# tensor([[0.5464, 0.5692],# [0.7211, 1.2168]])Pytorch的索引和python一样调整shapetorch.view() 调整数组shapetorch.size() 查看数据shapeimport torchx torch.randn(4, 4)y x.view(16)print(y.size()) # torch.Size([16])z x.view(-1, 8)print(z.size()) # torch.Size([2, 8])如果我们的张量只有一个数值可以使用.item()获取import torchx torch.randn(1)print(x) # tensor([-0.8504])print(x.item()) # -0.8503872156143188Numpy数组和Torch Tensor转换将Torch张量转换为NumPy数组ndarray.numpy()Torch Tensor--ndarrayimport torcha torch.ones(5)print(a) # tensor([1., 1., 1., 1., 1.])# torch tensor--ndarrayb a.numpy()print(b, type(b)) # [1. 1. 1. 1. 1.] 将NumPy数组转换为Torch张量torch.from_numpy(ndarray)ndarray--Torch Tensorimport torchimport numpy as npa np.ones(5) # [1. 1. 1. 1. 1.]b torch.from_numpy(a)print(b) # tensor([1., 1., 1., 1., 1.], dtypetorch.float64)Autograd自动微分自动微分Autograd用于自动计算复杂函数的梯度用于神经网络的优化如果设置torch.tensor_1(requires_gradTrue)那么会追踪所有对该张量tensor_1的所有操作。import torch# 创建一个张量并设置 requires_gradTrue 用来追踪他的计算历史x torch.ones(2, 2, requires_gradTrue)print(x)# tensor([[1., 1.],# [1., 1.]], requires_gradTrue)当Tensor完成一个计算过程每个张量都会自动生成一个.grad_fn属性# 对张量进行计算操作grad_fn已经被自动生成了。y x 2print(y)# tensor([[3., 3.],# [3., 3.]], grad_fn)print(y.grad_fn)# # 对y进行一个乘法操作z y * y * 3out z.mean()print(z)# tensor([[27., 27.],# [27., 27.]], grad_fn)print(out)# tensor(27., grad_fn).requires_grad_(...) 可以改变张量的requires_grad属性。 import torcha torch.randn(2, 2)a ((a * 3) / (a - 1))print(a.requires_grad) # 默认是requires_grad Falsea.requires_grad_(True)print(a.requires_grad) # Trueb (a * a).sum()print(b.grad_fn) # 梯度回顾到上面import torch# 创建一个张量并设置 requires_gradTrue 用来追踪他的计算历史x torch.ones(2, 2, requires_gradTrue)print(x)# tensor([[1., 1.],# [1., 1.]], requires_gradTrue)# 对张量进行计算操作grad_fn已经被自动生成了。y x 2print(y)# tensor([[3., 3.],# [3., 3.]], grad_fn)print(y.grad_fn)# # 对y进行一个乘法操作z y * y * 3out z.mean()print(z)# tensor([[27., 27.],# [27., 27.]], grad_fn)print(out)# tensor(27., grad_fn)print(out) # tensor(27., grad_fn)print(**50)out.backward()# 打印梯度print(x.grad)# tensor([[4.5000, 4.5000],# [4.5000, 4.5000]])import torchx torch.randn(3, requires_gradTrue)y x * 2while y.data.norm() 1000: y y * 2print(y) # tensor([-920.6895, -115.7301, -867.6995], grad_fn)gradients torch.tensor([0.1, 1.0, 0.0001], dtypetorch.float)# 把gradients代入y的反向传播中y.backward(gradients)# 计算梯度print(x.grad) # tensor([ 51.2000, 512.0000, 0.0512])为了防止跟踪历史记录可以将代码块包装在with torch.no_grad()中。在评估模型时特别有用因为模型的可训练参数的属性可能具有requires_grad True但是我们不需要梯度计算。print(x.requires_grad) # Trueprint((x ** 2).requires_grad) # Truewith torch.no_grad():print((x ** 2).requires_grad) # False神经网络神经网络是基于自动梯度 (autograd)来定义一些模型。一个 nn.Module 包括层和一个 forward(input) 它会返回输出(output)。一个典型的神经网络训练过程包括以下几点定义一个包含可训练参数的神经网络迭代整个输入通过神经网络处理输入计算损失(loss)反向传播梯度到神经网络的参数更新网络的参数典型的用一个简单的更新方法weight weight - learning_rate *gradient我们先来定义一个网络处理输入调用backwordimport torchimport torch.nn as nnimport torch.nn.functional as Fclass Net(nn.Module):def __init__(self): super(Net, self).__init__()# 1 input image channel, 6 output channels, 3x3 square convolution# kernel self.conv1 nn.Conv2d(1, 6, 3) self.conv2 nn.Conv2d(6, 16, 3)# an affine operation: y Wx b self.fc1 nn.Linear(16 * 6 * 6, 120) # 6*6 from image dimension self.fc2 nn.Linear(120, 84) self.fc3 nn.Linear(84, 10)def forward(self, x):# (2, 2)大小的最大池化层 x F.max_pool2d(F.relu(self.conv1(x)), (2, 2))# 如果大小是正方形则只能指定一个数字 x F.max_pool2d(F.relu(self.conv2(x)), 2) x x.view(-1, self.num_flat_features(x)) x F.relu(self.fc1(x)) x F.relu(self.fc2(x)) x self.fc3(x)return xdef num_flat_features(self, x):print(x.size()) # torch.Size([1, 16, 6, 6]) size x.size()[1:] # 除batch维度外的所有维度print(size) # torch.Size([16, 6, 6]) num_features 1for s in size: num_features * sreturn num_featuresnet Net()print(net) # 打印模型结构# Net(# (conv1): Conv2d(1, 6, kernel_size(3, 3), stride(1, 1))# (conv2): Conv2d(6, 16, kernel_size(3, 3), stride(1, 1))# (fc1): Linear(in_features576, out_features120, biasTrue)# (fc2): Linear(in_features120, out_features84, biasTrue)# (fc3): Linear(in_features84, out_features10, biasTrue))torch.nn只支持批输入格式sSamples * nChannels * Height * Width(样本数*通道数*高*宽)如果我们只有一个样本只需使用 input.unsqueeze(0) 来添加其它的维数一个模型可训练的参数可以通过调用 net.parameters() 返回params list(net.parameters())print(len(params)) # 10print(params[0].size()) # 第一个卷积层的权重 torch.Size([6, 1, 3, 3])让我们尝试随机生成一个 32x32 的输入input torch.randn(1, 1, 32, 32)out net(input)print(out)# tensor([[ 0.1464, 0.0453, 0.0269, 0.0078, 0.1960, -0.1795, 0.1265,# -0.0742, -0.0649, 0.0592]], grad_fn)把所有参数梯度缓存器置零用随机的梯度来反向传播# 把所有参数梯度缓存器置零net.zero_grad()# 用随机的梯度来反向传播out.backward(torch.randn(1, 10))损失函数计算均方误差 $lossnn.MSELoss(模型预测值-目标)output net(input) # torch.Size([1, 10])target torch.randn(10) # 随便取一个targettarget target.view(1, -1) # 让target和output的shape一样criterion nn.MSELoss()loss criterion(output, target)print(loss) # tensor(0.8695, grad_fn)现在如果你跟随损失到反向传播路径可以使用它的 .grad_fn 属性你将会看到一个这样的计算图input - conv2d - relu - maxpool2d - conv2d - relu - maxpool2d - view - linear - relu - linear - relu - linear - MSELoss - loss所以当我们调用 loss.backward()整个图都会微分而且所有的在图中的requires_gradTrue 的张量将会让他们的 grad 张量累计梯度。为了演示我们将跟随以下步骤来反向传播。print(loss.grad_fn) # MSELoss# print(loss.grad_fn.next_functions[0][0]) # Linear# print(loss.grad_fn.next_functions[0][0].next_functions[0][0]) # ReLU# 反向传播为了实现反向传播损失我们所有需要做的事情仅仅是使用 loss.backward()。你需要清空现存的梯度要不然将会和现存的梯度累计到一起。现在我们调用 loss.backward() 然后看一下 con1 的偏置项在反向传播之前和之后的变化。net.zero_grad() # 将所有参数的梯度缓冲区归零print(‘conv1.bias.grad 反向传播之前‘)print(net.conv1.bias.grad)# tensor([0., 0., 0., 0., 0., 0.])loss.backward()print(‘conv1.bias.grad 反向传播之后‘)print(net.conv1.bias.grad)# tensor([-0.0118, 0.0125, -0.0085, -0.0225, 0.0125, 0.0235])随机梯度下降更新神经网络参数基于python实现weight weight - learning_rate * gradientlearning_rate 0.01for f in net.parameters(): f.data.sub_(f.grad.data * learning_rate)使用torch.optim实现torch.optim中包含SGD, Nesterov-SGD, Adam, RMSProp, 等优化器import torch.optim as optim# create your optimizeroptimizer optim.SGD(net.parameters(), lr0.01)# in your training loop:optimizer.zero_grad() # zero the gradient buffersoutput net(input)loss criterion(output, target)loss.backward()optimizer.step() # Does the update图像分类器torch有一个叫做totchvision 的包支持加载类似ImagenetCIFAR10MNIST 等公共数据集的数据加载模块 torchvision.datasets支持加载图像数据数据转换模块 torch.utils.data.DataLoader。本节我们使用CIFAR10数据集它包含十个类别‘airplane’, ‘automobile’, ‘bird’, ‘cat’, ‘deer’, ‘dog’, ‘frog’, ‘horse’, ‘ship’, ‘truck’。CIFAR-10 中的图像尺寸为33232也就是RGB的3层颜色通道每层通道内的尺寸为32*32。训练一个图像分类器我们将按次序的做如下几步使用torchvision加载并且归一化CIFAR10的训练和测试数据集定义一个卷积神经网络定义一个损失函数在训练样本数据上训练网络在测试样本数据上测试网络torchvision 数据集的输出是范围在[0,1]之间的 PILImage我们将他们转换成归一化范围为[-1,1]之间的张量 Tensors。import torchimport torchvisionimport torchvision.transforms as transformstransform transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])# 下载训练数据集trainset torchvision.datasets.CIFAR10(root‘./data‘, trainTrue, downloadTrue, transformtransform)# 下载测试数据集testset torchvision.datasets.CIFAR10(root‘./data‘, trainFalse, downloadTrue, transformtransform)trainloader torch.utils.data.DataLoader(trainset, batch_size4, shuffleTrue, num_workers2)testloader torch.utils.data.DataLoader(testset, batch_size4, shuffleFalse, num_workers2)classes (‘plane‘, ‘car‘, ‘bird‘, ‘cat‘, ‘deer‘, ‘dog‘, ‘frog‘, ‘horse‘, ‘ship‘, ‘truck‘)让我们来展示其中的一些训练图片import matplotlib.pyplot as pltimport numpy as np# 展示图片def imshow(img): img img / 2 0.5 # unnormalize npimg img.numpy() plt.imshow(np.transpose(npimg, (1, 2, 0))) plt.show()# 获取一些随机的训练图片dataiter iter(trainloader)images, labels dataiter.next()imshow(torchvision.utils.make_grid(images)) # show images# 打印 labelsprint(‘ ‘.join(‘%5s‘ % classes[labels[j]] for j in range(4)))# cat plane ship frog定义一个卷积神经网络 在这之前先 从神经网络章节 复制神经网络并修改它为3通道的图片(在此之前它被定义为1通道)import torch.nn as nnimport torch.nn.functional as Fclass Net(nn.Module):def __init__(self): super(Net, self).__init__() self.conv1 nn.Conv2d(3, 6, 5) self.pool nn.MaxPool2d(2, 2) self.conv2 nn.Conv2d(6, 16, 5) self.fc1 nn.Linear(16 * 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.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 xnet Net()定义一个损失函数和优化器 让我们使用交叉熵Cross-Entropy 作损失函数优化器使用SGDimport torch.optim as optimcriterion nn.CrossEntropyLoss()optimizer optim.SGD(net.parameters(), lr0.001, momentum0.9)我们只需要在数据迭代器上将数据循环传给网络和优化器 就可以。for epoch in range(2): # 多次循环数据集 running_loss 0.0for i, data in enumerate(trainloader, 0):# 获取输入 inputs, labels data# 把参数梯度归零 optimizer.zero_grad()# 前向传播(forward) 反向传播(backward) 优化器(optimize) outputs net(inputs) # 前向传播 loss criterion(outputs, labels) loss.backward() # 反向传播 optimizer.step() # 优化器 running_loss loss.item()if i % 2000 1999: # 每2000个小batch打印一次print(‘[%d, %5d] loss: %.3f‘ % (epoch 1, i 1, running_loss / 2000)) running_loss 0.0print(‘Finished Training‘)# [1, 2000] loss: 2.187# [1, 4000] loss: 1.852# [1, 6000] loss: 1.672# [1, 8000] loss: 1.566# [1, 10000] loss: 1.490# [1, 12000] loss: 1.461# [2, 2000] loss: 1.389# [2, 4000] loss: 1.364# [2, 6000] loss: 1.343# [2, 8000] loss: 1.318# [2, 10000] loss: 1.282# [2, 12000] loss: 1.286# Finished Training在测试集上测试网络 我们已经通过训练数据集对网络进行了2次训练但是我们需要检查网络是否已经学到了东西。我们将用神经网络的输出作为预测的类标来检查网络的预测性能用样本的真实类标来校对。如果预测是正确的我们将样本添加到正确预测的列表里。好的第一步让我们从测试集中显示一张图像来熟悉它。GroundTruth: cat ship ship plane测试输出是预测与十个类的近似程度与某一个类的近似程度越高网络就越认为图像是属于这一类别。所以让我们打印其中最相似类别类标outputs net(images)_, predicted torch.max(outputs, 1)print(‘Predicted: ‘, ‘ ‘.join(‘%5s‘ % classes[predicted[j]] for j in range(4)))# Predicted: cat ship car ship# GroundTruth: cat ship ship plane预测对了两个让我们看看网络在整个数据集上的表现。correct 0total 0with torch.no_grad():for data in testloader: images, labels data outputs net(images) _, predicted torch.max(outputs.data, 1) total labels.size(0) correct (predicted labels).sum().item()print(‘Accuracy of the network on the 10000 test images: %d %%‘ % (100 * correct / total))# Accuracy of the network on the 10000 test images: 54 %正确率有54%看来网络学到了东西。随机预测出为10类中的哪一类class_correct list(0. for i in range(10))class_total list(0. for i in range(10))with torch.no_grad():for data in testloader: images, labels data outputs net(images) _, predicted torch.max(outputs, 1) c (predicted labels).squeeze()for i in range(4): label labels[i] class_correct[label] c[i].item() class_total[label] 1for i in range(10):print(‘Accuracy of %5s : %2d %%‘ % ( classes[i], 100 * class_correct[i] / class_total[i]))# Accuracy of plane : 57 %# Accuracy of car : 73 %# Accuracy of bird : 49 %# Accuracy of cat : 54 %# Accuracy of deer : 18 %# Accuracy of dog : 20 %# Accuracy of frog : 58 %# Accuracy of horse : 74 %# Accuracy of ship : 70 %# Accuracy of truck : 66 %在GPU上跑这些神经网络在GPU上训练我么要将神经网络转到GPU上。前提条件是CUDA可以用让我们首先定义下我们的设备为第一个可见的cuda设备。device torch.device(cuda:0 if torch.cuda.is_available() else cpu)# Assume that we are on a CUDA machine, then this should print a CUDA device:print(device)# cuda:0接着这些方法会递归地遍历所有模块并将它们的参数和缓冲器转换为CUDA张量。net.to(device)记住你也必须在每一个步骤向GPU发送输入和目标inputs, labels inputs.to(device), labels.to(device)CUDA张量使用该.to方法可以将张量移动到任何设备上。只有在有CUDA的情况下我们才能运行这个函数# 我们将使用“torch.device”对象来移动GPU中的张量if torch.cuda.is_available(): device torch.device(cuda) # CUDA设备对象 y torch.ones_like(x, devicedevice) # 直接在GPU上创建张量 x x.to(device) # 或者只使用 .to(cuda) z x yprint(z)print(z.to(cpu, torch.double)) # .to()还可以更改数据类型# tensor([0.7032], device‘cuda:0‘)# tensor([0.7032], dtypetorch.float64)数据并行处理本章节教大家如何使用DataParallel来使用多GPU。我们把模型放入GPU中 device torch.device(cuda:0) model.to(device)将所有张量复制到GPUmytensor my_tensor.to(device)在多 GPU 中执行前向、方向操作是非常自然的。尽管如此PyTorch 默认只会使用一个 GPU。因此我们要使用DataParallel让模型在多个GPU上并行运行。输入和参数import torchimport torch.nn as nnfrom torch.utils.data import Dataset, DataLoaderinput_size 5output_size 2batch_size 30data_size 100# 设备device torch.device(cuda:0 if torch.cuda.is_available() else cpu)制造一个随机的数据集class RandomDataset(Dataset):def __init__(self, size, length): self.len length self.data torch.randn(length, size)def __getitem__(self, index):return self.data[index]def __len__(self):return self.lenrand_loader DataLoader(datasetRandomDataset(input_size, data_size), batch_sizebatch_size, shuffleTrue)搭建一个简单的模型我们的模型仅获取输入执行线性运算并给出输出class Model(nn.Module):def __init__(self, input_size, output_size): super(Model, self).__init__() self.fc nn.Linear(input_size, output_size)def forward(self, input): output self.fc(input)print(\tIn Model: input size, input.size(), output size, output.size())return output创建模型和数据并行我们先要检查模型是否有多个GPU如果有我们再使用nn.DataParallel然后我们可以把模型放在GPU上model.to(device)model Model(input_size, output_size)if torch.cuda.device_count() 1:print(我们有, torch.cuda.device_count(), 个GPUs!)# dim 0 [30, xxx] - [10, ...], [10, ...], [10, ...] on 3 GPUs model nn.DataParallel(model)model.to(device)# 我们有2个GPU运行模型现在我们可以看到输入和输出张量的大小了for data in rand_loader: input data.to(device) output model(input)print(Outside: input size, input.size(), output_size, output.size())输出 In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2]) In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2]) In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2]) In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2]) In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2]) In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2]) In Model: input size torch.Size([5, 5]) output size torch.Size([5, 2]) In Model: input size torch.Size([5, 5]) output size torch.Size([5, 2])Outside: input size torch.Size([10, 5]) output_size torch.Size([10, 2])如果我们有2个GPU我们可以看到以下结果# on 2 GPUsLet‘s use 2 GPUs! In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2]) In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2]) In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2]) In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2]) In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2]) In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2]) In Model: input size torch.Size([5, 5]) output size torch.Size([5, 2]) In Model: input size torch.Size([5, 5]) output size torch.Size([5, 2])Outside: input size torch.Size([10, 5]) output_size torch.Size([10, 2])数据并行自动拆分了你的数据并且将任务单发送到多个 GPU 上。当每一个模型都完成自己的任务之后DataParallel 收集并且合并这些结果然后再返回给你。其他学习资料http://pytorch123.com/PyTroc官方文档https://pytorch.org/PyTroch中文文档https://pytorch-cn.readthedocs.io/zh/latest/PyTroch中文网https://www.pytorchtutorial.com简单易上手的PyTorch中文文档https://github.com/fendouai/pytorch1.0-cn未来地图物联--数联--智联【物联】物联数据建模—时空序列分析 第一章感知数据治理 第二章时空序列建模 第三章 单元时间序列第四章多维时间序列物联网数据分析体系物联数据建模探讨GeoMAN基于multi-level attention机制的传感器时间序列预测模型【数联】什么是数据科学大数据与数据科学课程体系这样搞定数据科学自学福利数据科学课程体系框架如何成为一名数据科学家【智联】三个角度理解知识图谱图数据挖掘VS知识图谱挖掘下个拐点图神经网络详细的知识图谱构建流程基于知识图谱推理的关系推演基于知识图谱的智能问答
