Pytorch GPU加速

import torch

import torch.nn.functional as F

import  torch

import  torch.nn as nn

import  torch.nn.functional as F

import  torch.optim as optim

from    torchvision import datasets, transforms

#超参数

batch_size=200

learning_rate=0.01

epochs=10

#获取训练数据

train_loader = torch.utils.data.DataLoader(

    datasets.MNIST('../data', train=True, download=True,          #train=True则得到的是训练集

                   transform=transforms.Compose([                 #transform进行数据预处理

                       transforms.ToTensor(),                     #转成Tensor类型的数据

                       transforms.Normalize((0.1307,), (0.3081,)) #进行数据标准化(减去均值除以方差)

                   ])),

    batch_size=batch_size, shuffle=True)                          #按batch_size分出一个batch维度在最前面,shuffle=True打乱顺序

#获取测试数据

test_loader = torch.utils.data.DataLoader(

    datasets.MNIST('../data', train=False, transform=transforms.Compose([

        transforms.ToTensor(),

        transforms.Normalize((0.1307,), (0.3081,))

    ])),

    batch_size=batch_size, shuffle=True)

class MLP(nn.Module):

    def __init__(self):

        super(MLP, self).__init__()

        self.model = nn.Sequential(         #定义网络的每一层，nn.ReLU可以换成其他激活函数，比如nn.LeakyReLU()

            nn.Linear(784, 200),

            nn.ReLU(inplace=True),

            nn.Linear(200, 200),

            nn.ReLU(inplace=True),

            nn.Linear(200, 10),

            nn.ReLU(inplace=True),

        )

    def forward(self, x):

        x = self.model(x)

        return x

net = MLP()

#定义sgd优化器,指明优化参数、学习率，net.parameters()得到这个类所定义的网络的参数[[w1,b1,w2,b2,...]

optimizer = optim.SGD(net.parameters(), lr=learning_rate)

criteon = nn.CrossEntropyLoss()

for epoch in range(epochs):

    for batch_idx, (data, target) in enumerate(train_loader):

        data = data.view(-1, 28*28)          #将二维的图片数据摊平[样本数,784]

        logits = net(data)                   #前向传播

        loss = criteon(logits, target)       #nn.CrossEntropyLoss()自带Softmax

        optimizer.zero_grad()                #梯度信息清空

        loss.backward()                      #反向传播获取梯度

        optimizer.step()                     #优化器更新

        if batch_idx % 100 == 0:             #每100个batch输出一次信息

            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(

                epoch, batch_idx * len(data), len(train_loader.dataset),

                       100. * batch_idx / len(train_loader), loss.item()))

    test_loss = 0

    correct = 0                                         #correct记录正确分类的样本数

    for data, target in test_loader:

        data = data.view(-1, 28 * 28)

        logits = net(data)

        test_loss += criteon(logits, target).item()     #其实就是criteon(logits, target)的值，标量

        pred = logits.data.max(dim=1)[1]                #也可以写成pred=logits.argmax(dim=1)

        correct += pred.eq(target.data).sum()

    test_loss /= len(test_loader.dataset)

    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(

        test_loss, correct, len(test_loader.dataset),

        100. * correct / len(test_loader.dataset)))

C:\Users\ygx79\AppData\Local\Programs\Python\Python37\lib\site-packages\torchvision\io\image.py:11: UserWarning: Failed to load image Python extension: [WinError 126] 找不到指定的模块。

  warn(f"Failed to load image Python extension: {e}")

Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz

Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ../data\MNIST\raw\train-images-idx3-ubyte.gz

9913344it [09:45, 16922.35it/s]                              

Extracting ../data\MNIST\raw\train-images-idx3-ubyte.gz to ../data\MNIST\raw

Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz

Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ../data\MNIST\raw\train-labels-idx1-ubyte.gz

29696it [00:00, 112126.01it/s]                          

Extracting ../data\MNIST\raw\train-labels-idx1-ubyte.gz to ../data\MNIST\raw

Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz

Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ../data\MNIST\raw\t10k-images-idx3-ubyte.gz

1649664it [00:06, 236143.14it/s]                             

Extracting ../data\MNIST\raw\t10k-images-idx3-ubyte.gz to ../data\MNIST\raw

Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz

Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ../data\MNIST\raw\t10k-labels-idx1-ubyte.gz

5120it [00:00, ?it/s]                   

Extracting ../data\MNIST\raw\t10k-labels-idx1-ubyte.gz to ../data\MNIST\raw

Train Epoch: 0 [0/60000 (0%)]	Loss: 2.307192

Train Epoch: 0 [20000/60000 (33%)]	Loss: 2.138816

Train Epoch: 0 [40000/60000 (67%)]	Loss: 1.768016

Test set: Average loss: 0.0070, Accuracy: 6058/10000 (61%)

Train Epoch: 1 [0/60000 (0%)]	Loss: 1.505597

Train Epoch: 1 [20000/60000 (33%)]	Loss: 1.149395

Train Epoch: 1 [40000/60000 (67%)]	Loss: 1.039293

Test set: Average loss: 0.0047, Accuracy: 7143/10000 (71%)

Train Epoch: 2 [0/60000 (0%)]	Loss: 1.061429

Train Epoch: 2 [20000/60000 (33%)]	Loss: 0.741140

Train Epoch: 2 [40000/60000 (67%)]	Loss: 0.901448

Test set: Average loss: 0.0041, Accuracy: 7299/10000 (73%)

Train Epoch: 3 [0/60000 (0%)]	Loss: 0.809117

Train Epoch: 3 [20000/60000 (33%)]	Loss: 0.892138

Train Epoch: 3 [40000/60000 (67%)]	Loss: 0.659411

Test set: Average loss: 0.0030, Accuracy: 8170/10000 (82%)

Train Epoch: 4 [0/60000 (0%)]	Loss: 0.622007

Train Epoch: 4 [20000/60000 (33%)]	Loss: 0.592337

Train Epoch: 4 [40000/60000 (67%)]	Loss: 0.445400

Test set: Average loss: 0.0027, Accuracy: 8225/10000 (82%)

Train Epoch: 5 [0/60000 (0%)]	Loss: 0.519135

Train Epoch: 5 [20000/60000 (33%)]	Loss: 0.491247

Train Epoch: 5 [40000/60000 (67%)]	Loss: 0.562315

Test set: Average loss: 0.0026, Accuracy: 8295/10000 (83%)

Train Epoch: 6 [0/60000 (0%)]	Loss: 0.509583

Train Epoch: 6 [20000/60000 (33%)]	Loss: 0.553628

Train Epoch: 6 [40000/60000 (67%)]	Loss: 0.484189

Test set: Average loss: 0.0025, Accuracy: 8336/10000 (83%)

Train Epoch: 7 [0/60000 (0%)]	Loss: 0.619250

Train Epoch: 7 [20000/60000 (33%)]	Loss: 0.634936

Train Epoch: 7 [40000/60000 (67%)]	Loss: 0.440220

Test set: Average loss: 0.0024, Accuracy: 8370/10000 (84%)

Train Epoch: 8 [0/60000 (0%)]	Loss: 0.410350

Train Epoch: 8 [20000/60000 (33%)]	Loss: 0.460459

Train Epoch: 8 [40000/60000 (67%)]	Loss: 0.395150

Test set: Average loss: 0.0024, Accuracy: 8395/10000 (84%)

Train Epoch: 9 [0/60000 (0%)]	Loss: 0.515630

Train Epoch: 9 [20000/60000 (33%)]	Loss: 0.546718

Train Epoch: 9 [40000/60000 (67%)]	Loss: 0.496167

Test set: Average loss: 0.0023, Accuracy: 8433/10000 (84%)

device = torch.device('cuda:0')

net = MLP().to(device)

#定义sgd优化器,指明优化参数、学习率，net.parameters()得到这个类所定义的网络的参数[[w1,b1,w2,b2,...]

optimizer = optim.SGD(net.parameters(), lr=learning_rate)

criteon = nn.CrossEntropyLoss().to(device)

GPU acc

import  torch

import  torch.nn as nn

import  torch.nn.functional as F

import  torch.optim as optim

from    torchvision import datasets, transforms

#超参数

batch_size=200

learning_rate=0.01

epochs=10

#获取训练数据

train_loader = torch.utils.data.DataLoader(

    datasets.MNIST('../data', train=True, download=True,          #train=True则得到的是训练集

                   transform=transforms.Compose([                 #transform进行数据预处理

                       transforms.ToTensor(),                     #转成Tensor类型的数据

                       transforms.Normalize((0.1307,), (0.3081,)) #进行数据标准化(减去均值除以方差)

                   ])),

    batch_size=batch_size, shuffle=True)                          #按batch_size分出一个batch维度在最前面,shuffle=True打乱顺序

#获取测试数据

test_loader = torch.utils.data.DataLoader(

    datasets.MNIST('../data', train=False, transform=transforms.Compose([

        transforms.ToTensor(),

        transforms.Normalize((0.1307,), (0.3081,))

    ])),

    batch_size=batch_size, shuffle=True)

class MLP(nn.Module):

    def __init__(self):

        super(MLP, self).__init__()

        self.model = nn.Sequential(         #定义网络的每一层,

            nn.Linear(784, 200),

            nn.ReLU(inplace=True),

            nn.Linear(200, 200),

            nn.ReLU(inplace=True),

            nn.Linear(200, 10),

            nn.ReLU(inplace=True),

        )

    def forward(self, x):

        x = self.model(x)

        return x

device = torch.device('cuda:0')

net = MLP().to(device)

#定义sgd优化器,指明优化参数、学习率，net.parameters()得到这个类所定义的网络的参数[[w1,b1,w2,b2,...]

optimizer = optim.SGD(net.parameters(), lr=learning_rate)

criteon = nn.CrossEntropyLoss().to(device)

for epoch in range(epochs):

    for batch_idx, (data, target) in enumerate(train_loader):

        data = data.view(-1, 28*28)          #将二维的图片数据摊平[样本数,784]

        data, target = data.to(device), target.cuda()

        logits = net(data)               #前向传播

        loss = criteon(logits, target)       #nn.CrossEntropyLoss()自带Softmax

        optimizer.zero_grad()                #梯度信息清空

        loss.backward()                      #反向传播获取梯度

        optimizer.step()                     #优化器更新

        if batch_idx % 100 == 0:             #每100个batch输出一次信息

            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(

                epoch, batch_idx * len(data), len(train_loader.dataset),

                       100. * batch_idx / len(train_loader), loss.item()))

    test_loss = 0

    correct = 0                                         #correct记录正确分类的样本数

    for data, target in test_loader:

        data = data.view(-1, 28 * 28)

        data, target = data.to(device), target.cuda()

        logits = net(data)

        test_loss += criteon(logits, target).item()     #其实就是criteon(logits, target)的值，标量

        pred = logits.data.max(dim=1)[1]                #也可以写成pred=logits.argmax(dim=1)

        correct += pred.eq(target.data).sum()

    test_loss /= len(test_loader.dataset)

    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(

        test_loss, correct, len(test_loader.dataset),

        100. * correct / len(test_loader.dataset)))

Train Epoch: 0 [0/60000 (0%)]	Loss: 2.291108

Train Epoch: 0 [20000/60000 (33%)]	Loss: 2.003711

Train Epoch: 0 [40000/60000 (67%)]	Loss: 1.419139

Test set: Average loss: 0.0038, Accuracy: 8229/10000 (82%)

Train Epoch: 1 [0/60000 (0%)]	Loss: 0.754257

Train Epoch: 1 [20000/60000 (33%)]	Loss: 0.655030

Train Epoch: 1 [40000/60000 (67%)]	Loss: 0.444529

Test set: Average loss: 0.0021, Accuracy: 8884/10000 (89%)

Train Epoch: 2 [0/60000 (0%)]	Loss: 0.439030

Train Epoch: 2 [20000/60000 (33%)]	Loss: 0.355868

Train Epoch: 2 [40000/60000 (67%)]	Loss: 0.366360

Test set: Average loss: 0.0017, Accuracy: 9037/10000 (90%)

Train Epoch: 3 [0/60000 (0%)]	Loss: 0.439010

Train Epoch: 3 [20000/60000 (33%)]	Loss: 0.344060

Train Epoch: 3 [40000/60000 (67%)]	Loss: 0.255032

Test set: Average loss: 0.0015, Accuracy: 9116/10000 (91%)

Train Epoch: 4 [0/60000 (0%)]	Loss: 0.331074

Train Epoch: 4 [20000/60000 (33%)]	Loss: 0.301065

Train Epoch: 4 [40000/60000 (67%)]	Loss: 0.276514

Test set: Average loss: 0.0014, Accuracy: 9169/10000 (92%)

Train Epoch: 5 [0/60000 (0%)]	Loss: 0.281249

Train Epoch: 5 [20000/60000 (33%)]	Loss: 0.316320

Train Epoch: 5 [40000/60000 (67%)]	Loss: 0.248902

Test set: Average loss: 0.0013, Accuracy: 9210/10000 (92%)

Train Epoch: 6 [0/60000 (0%)]	Loss: 0.317820

Train Epoch: 6 [20000/60000 (33%)]	Loss: 0.315888

Train Epoch: 6 [40000/60000 (67%)]	Loss: 0.302683

Test set: Average loss: 0.0013, Accuracy: 9258/10000 (93%)

Train Epoch: 7 [0/60000 (0%)]	Loss: 0.290187

Pytorch GPU加速的更多相关文章

56 Marvin: 一个支持GPU加速、且不依赖其他库（除cuda和cudnn）的轻量化多维深度学习（deep learning）框架介绍
0 引言 Marvin是普林斯顿视觉实验室(PrincetonVision)于2015年提出的轻量化GPU加速的多维深度学习网络框架.该框架采用纯c/c++编写,除了cuda和cudnn以外,不依赖其 ...
手把手教你在win10下搭建pytorch GPU环境（Anaconda+Pycharm）
Anaconda指的是一个开源的Python发行版本,其主要优点如下: Anaconda默认安装了常见的科学计算包,用它搭建起Python环境后不用再费时费力安装这些包: Anaconda可以创建互相 ...
0704-使用GPU加速_cuda
0704-使用GPU加速_cuda 目录一.CPU 和 GPU 数据相互转换二.使用 GPU 的注意事项三.设置默认 GPU 四.GPU 之间的切换 pytorch完整教程目录:https:// ...
GPU加速计算
GPU加速计算 NVIDIA A100 Tensor Core GPU 可针对 AI.数据分析和高性能计算 (HPC),在各种规模上实现出色的加速,应对极其严峻的计算挑战.作为 NVIDIA 数据中心 ...
GPU—加速数据科学工作流程
GPU-加速数据科学工作流程 GPU-ACCELERATE YOUR DATA SCIENCE WORKFLOWS 传统上,数据科学工作流程是缓慢而繁琐的,依赖于cpu来加载.过滤和操作数据,训练和部 ...
深度学习GPU加速配置方法
深度学习GPU加速配置方法一.英伟达官方驱动及工具安装首先检查自己的电脑驱动版本,未更新至最新建议先将驱动更新至最新,然后点击Nvidia控制面板 2.在如下界面中点击系统信息,点击显示可以看见当 ...
Theano在windows下的安装及GPU加速
安装环境:wondows 64bit Teano安装测试 1. Anaconda 安装 Anaconda是一个科学计算环境,自带的包管理器conda很强大.之所以选择它是因为它内置了python,以及 ...
GPU 加速NLP任务（Theano+CUDA）
之前学习了CNN的相关知识,提到Yoon Kim(2014)的论文,利用CNN进行文本分类,虽然该CNN网络结构简单效果可观,但论文没有给出具体训练时间,这便值得进一步探讨. Yoon Kim代码:h ...
开启gpu加速的高性能移动端相框组件！
通过设置新的css3新属性translateX来代替传统的绝对定位改变left值的动画原理,新属性translateX会开启浏览器自带的gpu硬件加速动画性能,提高流畅度从而提高用户体验, 代码有很详 ...
ubuntu 15 安装cuda，开启GPU加速
1 首先要开启GPU加速就要安装cuda.安装cuda,首先要安装英伟达的驱动.ubuntu有自带的开源驱动,首先要禁用nouveau.这儿要注意,虚拟机不能安装ubuntu驱动.VMWare下显卡只 ...

随机推荐

IDEA通过Spring Initalizr新建SSM (2)
之前的方式是通过官网初始化demo(URL:https://start.spring.io/)现在记录一下通过IDEA自带的初始化器新建SSM框架 1.打开IDEA,点击新建,出现如下图菜单,点击Sp ...
liunx部署flask项目
如何在linux上部署flask项目 Python3.7 + virtualenv + uwsgi + git + mysql-5.6.45 + nginx 源码编译安装所需要的环境 yum inst ...
JavaScript 基础学习（一）
JavaScript基础学习(一) 一.JavaScript概述 JavaScript的历史 1992年Nombas开发出C-minus-minus(C--)的嵌入式脚本语言(最初绑定在CEnvi软件 ...
HDLbits——Lfsr5
Build this LFSR. The reset should reset the LFSR to 1 module top_module( input clk, input reset, // ...
tomcat多主多备
主服务器默认轮询,当主服务器全部挂了,就会访问备机backup,备机也默认轮询
spring cloud 配置文件加密解密
1.底包 <dependency> <groupId>org.springframework.security</groupId> <artifact ...
[2002年NOIP提高组] 均分纸牌
有 N 堆纸牌,编号分别为 1,2,-, N.每堆上有若干张,但纸牌总数必为 N 的倍数.可以在任一堆上取若于张纸牌,然后移动.移牌规则为:在编号为 1 堆上取的纸牌,只能移到编号为 2 的堆上:在编 ...
Mysql学习：3、sql数据类型及命令
1.sql功能分类: 2.常见数据类型: 3.sql命令: DDL命令: a.创建数据库: create database testdatabase(数据库名称) character set utf8 ...
<雪山飞狐><飞狐外传 >合辑剧情+随笔
严格而言雪山飞狐与飞狐外传的剧情并不相关,前者写作与前,然后飞狐外传算是对雪山飞狐中形象并不饱满的胡斐作进一步补充描述,同时对二十余年前苗人凤与胡一刀之间故事的补充,以及众人叙述中的一些补充.因此虽然 ...
luogu 3676小清新数据结构题
真·小清新... 其实本题正解是动态点分治,但是考虑到那个东西需要先大力推导一波再套上一个幻想乡战略游戏的搞法,所以还不如大力推导一波,然后无脑套上一个树剖+线段树写法... 首先我们考虑没有换根操作 ...

Pytorch GPU加速

GPU acc

Pytorch GPU加速的更多相关文章

随机推荐

热门专题