加载中…
正文 字体大小:

pytorch资料汇总

(2017-01-20 09:52:53)
标签:

pytorch

深度学习

分类: 数据挖掘

pytorch资料汇总

pytorch,语法类似numpy,非常高效;基于pytorch开发深度学习算法,方便快速,适合cpu和gpu计算。pytorch支持动态构建神经网络结构,从而可以提升挽留过结构的重用性。


from __future__ import print_function
import torch

= torch.Tensor(53)

= torch.rand(53)

x

 0.6528  0.0866  0.6087
 0.8979  0.9326  0.6805
 0.0554  0.8358  0.0058
 0.2011  0.7566  0.2541
 0.4476  0.9304  0.9173
[torch.FloatTensor of size 5x3]

x.size()

torch.Size([5, 3])

= torch.rand(53)

+ y

 0.6891  0.9336  1.5928
 1.4953  1.4822  1.5263
 0.6218  1.7133  0.2795
 0.8883  0.7674  0.9020
 1.2286  1.7552  1.7655
[torch.FloatTensor of size 5x3]

torch.add(x, y)

 0.6891  0.9336  1.5928
 1.4953  1.4822  1.5263
 0.6218  1.7133  0.2795
 0.8883  0.7674  0.9020
 1.2286  1.7552  1.7655
[torch.FloatTensor of size 5x3]

#定义一个输出的tensor 
result = torch.Tensor(53)
torch.add(x, y, out=result)

 0.6891  0.9336  1.5928
 1.4953  1.4822  1.5263
 0.6218  1.7133  0.2795
 0.8883  0.7674  0.9020
 1.2286  1.7552  1.7655
[torch.FloatTensor of size 5x3]

result

 0.6891  0.9336  1.5928
 1.4953  1.4822  1.5263
 0.6218  1.7133  0.2795
 0.8883  0.7674  0.9020
 1.2286  1.7552  1.7655
[torch.FloatTensor of size 5x3]

y.add_(x)

 0.6891  0.9336  1.5928
 1.4953  1.4822  1.5263
 0.6218  1.7133  0.2795
 0.8883  0.7674  0.9020
 1.2286  1.7552  1.7655
[torch.FloatTensor of size 5x3]

x[:1]

 0.6528  0.0866  0.6087
[torch.FloatTensor of size 1x3]

x

 0.6528  0.0866  0.6087
 0.8979  0.9326  0.6805
 0.0554  0.8358  0.0058
 0.2011  0.7566  0.2541
 0.4476  0.9304  0.9173
[torch.FloatTensor of size 5x3]

x[:, 1]

 0.0866
 0.9326
 0.8358
 0.7566
 0.9304
[torch.FloatTensor of size 5]

#将torch tensor转化成numpy array 
= torch.ones(5)
print(a)
= a.numpy()
print(b)

 1
 1
 1
 1
 1
[torch.FloatTensor of size 5]
 
1.  1.  1.  1.  1.]

a.add_(1)
print(a)
print(b)
#share their underlying memory locations, and changing one will change the other. 

 2
 2
 2
 2
 2
[torch.FloatTensor of size 5]
 
2.  2.  2.  2.  2.]

#Converting numpy Array to torch Tensor¶ 
import numpy as np
= np.ones(5)
= torch.from_numpy(a)
np.add(a, 1out=a)
print(a)
print(b)

2.  2.  2.  2.  2.]
 
 2
 2
 2
 2
 2
[torch.DoubleTensor of size 5]

b

 2
 2
 2
 2
 2
[torch.DoubleTensor of size 5]

#Autograd: automatic differentiation framework 
from torch.autograd import Variable
= Variable(torch.ones(22)requires_grad=True)
x

Variable containing:
  1
  1
[torch.FloatTensor of size 2x2]

= + 2
y

Variable containing:
  3
  3
[torch.FloatTensor of size 2x2]

y.creator


= * * 3

z

Variable containing:
 27  27
 27  27
[torch.FloatTensor of size 2x2]

out = z.mean()
out

Variable containing:
 27
[torch.FloatTensor of size 1]

out.backward()

x.grad

Variable containing:
 4.5000  4.5000
 4.5000  4.5000
[torch.FloatTensor of size 2x2]

= torch.randn(3)
= Variable(x, requires_grad=True)

= * 2
while y.data.norm <</span> 1000:
    = * 2

y

Variable containing:
 0.7411
-1.6021
-0.7232
[torch.FloatTensor of size 3]

gradients = torch.FloatTensor([0.1, 1.0, 0.0001])
y.backward(gradients)

x.grad

Variable containing:
 0.2000
 2.0000
 0.0002
[torch.FloatTensor of size 3]

#神经网络 
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(165) # input image channel, output channels, 5x5 square convolution kernel 
        self.conv2 = nn.Conv2d(6165)
        self.fc1   = nn.Linear(16*5*5120) # an affine operation: Wx 
        self.fc2   = nn.Linear(12084)
        self.fc3   = nn.Linear(8410)
 
    def forward(self, x):
        = F.max_pool2d(F.relu(self.conv1(x))(22)) # Max pooling over (2, 2) window 
        = F.max_pool2d(F.relu(self.conv2(x))2) # If the size is square you can only specify single number 
        = x.view(-1self.num_flat_features(x))
        = F.relu(self.fc1(x))
        = F.relu(self.fc2(x))
        = self.fc3(x)
        return x
 
    def num_flat_features(self, x):
        size = x.size()[1:] # all dimensions except the batch dimension 
        num_features = 1
        for in size:
            num_features *= s
        return num_features
 
net = Net()
net

Net (
  (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
  (fc1): Linear (400 -> 120)
  (fc2): Linear (120 -> 84)
  (fc3): Linear (84 -> 10)
)

params = list(net.parameters())
print(len(params))
print(params[0].size()# conv1's .weight 

10
torch.Size([6, 1, 5, 5])

input = Variable(torch.randn(113232))
out = net(input)
out

Variable containing:
-0.0021  0.0284 -0.0429  0.1176 -0.0347 -0.0097  0.0857 -0.0272  0.0875 -0.0659
[torch.FloatTensor of size 1x10]

net.zero_grad() # zeroes the gradient buffers of all parameters 
out.backward(torch.randn(110)) # backprops with random gradients 

output = net(input)
target = Variable(torch.range(110))  # dummy target, for example 
criterion = nn.MSELoss()
loss = criterion(output, target)
loss

Variable containing:
 38.3687
[torch.FloatTensor of size 1]

# For illustration, let us follow few steps backward 
print(loss.creator) # MSELoss 
print(loss.creator.previous_functions[0][0]# Linear 
print(loss.creator.previous_functions[0][0].previous_functions[0][0]# ReLU 


# now we shall call loss.backward(), and have look at conv1's bias gradients before and after the backward. 
net.zero_grad() # zeroes the gradient buffers of all parameters 
print('conv1.bias.grad before backward')
print(net.conv1.bias.grad)
loss.backward()
print('conv1.bias.grad after backward')
print(net.conv1.bias.grad)

conv1.bias.grad before backward
Variable containing:
 0
 0
 0
 0
 0
 0
[torch.FloatTensor of size 6]
 
conv1.bias.grad after backward
Variable containing:
1.00000e-02 *
  0.4278
 -7.8947
  7.0225
 -1.5944
  9.4956
 -1.3269
[torch.FloatTensor of size 6]

import torch.optim as optim
# create your optimizer 
optimizer = optim.SGD(net.parameters()lr = 0.01)
 
# in your training loop: 
optimizer.zero_grad() # zero the gradient buffers 
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step() # Does the update 

#训练图片分类器 
import torchvision
import torchvision.transforms as transforms

transform=transforms.Compose([transforms.ToTensor(), 
                              transforms.Normalize((0.50.50.5), (0.50.50.5)), 
                             ])
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=2)
 
testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                          shuffle=False, num_workers=2)
classes = ('plane''car''bird''cat',
           'deer''dog''frog''horse''ship''truck')

Downloading http://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz

# functions to show an image 
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline
def imshow(img):
    img = img / 2 + 0.5 # unnormalize 
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1,2,0)))

# show some random training images 
dataiter = iter(trainloader)
images, labels = dataiter.next()
 
# print images 
imshow(torchvision.utils.make_grid(images))
# print labels 
print(' '.join('%5s'%classes[labels[j]] for in range(4)))

plane  frog  bird horse

pytorch资料汇总


#构建网络结构 
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(365)
        self.pool  = nn.MaxPool2d(2,2)
        self.conv2 = nn.Conv2d(6165)
        self.fc1   = nn.Linear(16*5*5120)
        self.fc2   = nn.Linear(12084)
        self.fc3   = nn.Linear(8410)
 
    def forward(self, x):
        = self.pool(F.relu(self.conv1(x)))
        = self.pool(F.relu(self.conv2(x)))
        = x.view(-116*5*5)
        = F.relu(self.fc1(x))
        = F.relu(self.fc2(x))
        = self.fc3(x)
        return x
 
net = Net()

#定义损失函数和优化器 
criterion = nn.CrossEntropyLoss() # use Classification Cross-Entropy loss 
optimizer = optim.SGD(net.parameters()lr=0.001, momentum=0.9)

#训练神经网络 
for epoch in range(2)# loop over the dataset multiple times 
 
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # get the inputs 
        inputs, labels = data
 
        # wrap them in Variable 
        inputs, labels = Variable(inputs)Variable(labels)
 
        # zero the parameter gradients 
        optimizer.zero_grad()
 
        # forward backward optimize 
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()        
        optimizer.step()
 
        # print statistics 
        running_loss += loss.data[0]
        if % 2000 == 1999# print every 2000 mini-batches 
            print('[%d]loss: %.3f' % (epoch+1i+1running_loss / 2000))
            running_loss = 0.0
print('Finished Training')

[1,  2000] loss: 2.161
[1,  4000] loss: 1.829
[1,  6000] loss: 1.676
[1,  8000] loss: 1.573
[1, 10000] loss: 1.510
[1, 12000] loss: 1.470
[2,  2000] loss: 1.402
[2,  4000] loss: 1.374
[2,  6000] loss: 1.326
[2,  8000] loss: 1.322
[2, 10000] loss: 1.308
[2, 12000] loss: 1.293
Finished Training

dataiter = iter(testloader)
images, labels = dataiter.next()
 
# print images 
imshow(torchvision.utils.make_grid(images))
print('GroundTruth: '' '.join('%5s'%classes[labels[j]] for in range(4)))

GroundTruth:    cat  ship  ship plane

pytorch资料汇总


outputs = net(Variable(images))
 
# the outputs are energies for the 10 classes. 
# Higher the energy for class, the more the network 
# thinks that the image is of the particular class 
 
# So, let's get the index of the highest energy 
_, predicted = torch.max(outputs.data, 1)
 
print('Predicted: '' '.join('%5s'% classes[predicted[j][0]] for in range(4)))

Predicted:    cat   car  ship plane

correct = 0
total = 0
for data in testloader:
    images, labels = data
    outputs = net(Variable(images))
    _, predicted = torch.max(outputs.data, 1)
    total += labels.size(0)
    correct += (predicted == labels).sum()
 
print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total))

Accuracy of the network on the 10000 test images: 55 %

class_correct = list(0. for in range(10))
class_total = list(0. for in range(10))
for data in testloader:
    images, labels = data
    outputs = net(Variable(images))
    _, predicted = torch.max(outputs.data, 1)
    = (predicted == labels).squeeze()
    for in range(4):
        label = labels[i]
        class_correct[label] += c[i]
        class_total[label] += 1

for in range(10):
    print('Accuracy of %5s - %%' % (classes[i]100 * class_correct[i] / class_total[i]))

Accuracy of plane 62 %
Accuracy of   car 83 %
Accuracy of  bird 45 %
Accuracy of   cat 28 %
Accuracy of  deer 42 %
Accuracy of   dog 36 %
Accuracy of  frog 62 %
Accuracy of horse 66 %
Accuracy of  ship 69 %
Accuracy of truck 56 %

参考资料
pytorch api接口文档 http://pytorch.org/docs/
pytorch 案例 https://github.com/pytorch/tutorials/blob/master/Deep Learning with PyTorch.ipynb
pytorch深度学习 https://github.com/pytorch/tutorials/blob/master/Introduction to PyTorch for former Torchies.ipynb

0

阅读 评论 收藏 转载 喜欢 打印举报
已投稿到:
  • 评论加载中,请稍候...
发评论

    发评论

    以上网友发言只代表其个人观点,不代表新浪网的观点或立场。

      

    新浪BLOG意见反馈留言板 不良信息反馈 电话:4006900000 提示音后按1键(按当地市话标准计费) 欢迎批评指正

    新浪简介 | About Sina | 广告服务 | 联系我们 | 招聘信息 | 网站律师 | SINA English | 会员注册 | 产品答疑

    新浪公司 版权所有