超简单！pytorch入门教程（一）：Tensor - 简书
超简单！pytorch入门教程（一）：Tensor
Zen君的配置是macbook pro，升级到Mac Serria安装不了qt，无法显示图片，好在发现了pytorch，正好Zen君以前也玩过python的，所以非常激动。这个教程系列也是趁着心情激动写下来的，不知道会不会持续更新，暂时别抱有期待：）一、pytorch安装安装pytorch之前，需要安装好python（废话），还没安装过python的宝宝请先移步到廖雪峰的python教程，待安装熟悉完之后，再过来这边。我们接着讲。打开pytorch官网，找到下图所示位置
如图所示，选择好系统，包管理工具，python的版本，是否支持CUDA（Zen君的配置是OSX，包管理工具是pip，版本2.7，不支持CUDA，哭）
选择好相应的配置，然后就可以复制下面“Run this command”的代码，直接打开命令台粘贴运行，即完成pytorch的安装。二、pytorch的基石--Tensor张量要介绍Tensor这个数据类型，我觉得有必要扯一下数学。我们都知道：标量（Scalar）是只有大小，没有方向的量，如1，2，3等向量（Vector）是有大小和方向的量，其实就是一串数字，如(1,2)矩阵（Matrix）是好几个向量拍成一排合并而成的一堆数字，如[1,2;3,4]
如图，我们可以看出，矩阵是二维的，向量是一维的，标量是零维的。
那么张量（Tensor）是什么呢？呵呵呵呵！大家估计也能猜出来！是按照三维排列的一堆数字？是的。但是也不完全正确。其实标量，向量，矩阵它们三个也是张量，标量是零维的张量，向量是一维的张量，矩阵是二维的张量。
张量就是按照任意维排列的一堆数字的推广。如图所示，矩阵不过是三维张量下的一个二维切面。要找到三维张量下的一个标量，需要三个维度的坐标来定位。
除此之外，张量还可以是四维的、五维的、。。。等等数学扯完了，我们撸串代码操练操练　(*ˉ︶ˉ*)
&&&import torch #引用torch包
&&&x = torch.Tensor(2,3)
#构造一个2x3的矩阵，没初始化但仍然会有值
8...0118e+28
4...4013e-45
[torch.FloatTensor of size 2x3]
#可以看出数据类型是浮点数的2x3矩阵
看矩阵看不出张量的道道，我们来点刺激的
&&&y=torch.Tensor(4,2,3) #构造一个4x2x3的张量，没初始化
(0 ,.,.) =
1.00000e-29 *
(1 ,.,.) =
1.00000e-29 *
(2 ,.,.) =
1.00000e-29 *
(3 ,.,.) =
1.00000e-29 *
[torch.FloatTensor of size 4x2x3]
我们从上面的返回值可以看出，4x2x3的张量y由4个2x3的矩阵构成，这符合了我们数学上的定义。Tensor的加法(四种)我们先初始化两个张量：
rand()用随机数初始化5x3的矩阵
第一种：&&&a+b第二种：&&&torch.add(a,b)第三种：
&&&result = torch.Tensor(5,3)
&&&torch.add(a,b,out=result) #把运算结果存储在result上
第四种：&&&b.add_(a) #把运算结果覆盖掉bTensor的部分截取
利用b[:,1]来截取第2列的所有元素（计算机是从0开始数，所以1是第2列）
Tensor的其他操作除了加法以外，还有上百种张量的操作，比如说转置（transposing），切片（slicing）等，送个给少侠，少侠自己在家慢慢操练了?。Tensor与numpy的Array的相互转换torch的tensor可以与numpy的array进行转换1.tensor=>array&&&b = a.numpy() #a为tensor
如图所示，b和a是共用一块内存，所以当a发生变化时，b也会发生变化。
2.array=>tensor&&&b = torch.from_numpy(a)
#a为numpy的array
如图所示，a和b一样是共用一块内存。
CUDA的神助攻假如少侠你有一块nvidia的显卡并支持cuda（如GTX 1080），那么恭喜你，你可以使用显卡gpu进行tensor的运算。假如你像Zen君一样没有，考虑买一个吧。。。&&&torch.cuda.is_available()
#看看是否支持cuda假如返回的是True那么，下面的代码将带你飞。
&&&x = x.cuda()
&&&y = y.cuda()
#这里的x和y都是tensor，使用cuda函数以后，x和y的所有运算均会调用gpu来运算。
简书初学者PyTorch快速入门教程一
接下来我们将进入Pytorch快速入门系列教程，本系列主要参考深度炼丹的知乎专栏,并且已经获得了作者的许可转载，同时文章会有较多改动，我将会以一个新手的视角带大家学习PyTorch，同时如果有不对的地方，欢迎大家到给我留言，大家也可以一觉分享交流！如果你还不知道pytorch是啥，可以去看一看以前的文章&
要学习pytorch，首先当然是需要安装pytorch了，目前pytorch只支持mac和linux，如果你的电脑是windows，装虚拟机或者双系统。如果想要愉快地学习，那么强烈推荐使用linux系统，因为所有的深度学习框架在linux上都有很好的支持，远远好于windows系统，而且linux也没有大家想象中的那么难学，目前linux系统的图形界面让大家上手的时候更加容易。
Linux或者Mac默认安装了python2.7系统，大家安装玩Linux系统以后接下来就是安装Pytorch了，其实安装很简单，大家可以参考：
pytorch基础
装好了pytorch之后，正式进入我们的教程，pytorch基础部分，这个部分主要是介绍一下pytorch处理的对象以及操作。
tensor就是张量的英文，表示多维的矩阵，比如一维就是向量，二维就是一般的矩阵等等，pytorch里面处理的单位就是一个一个的tensor
size可以显示的得到其大小
这个和numpy很相似，同时tensor和numpy.array之间也可以相互转换
tensor的运算也很简单，一般的四则运算都是支持的
pytorch和numpy不一样的地方就来了，就是其提供了自动求导功能，也就是可以自动给你你要的参数的梯度，这个操作又另外一个基本元素提供，Variable
本质上Variable和Tensor没有区别，不过Variabel会放入一个计算图，然后进行前向传播，反向传播以及自动求导
一个Variable里面包含着三个属性，data，grad和creator，其中creator表示得到这个Variabel的操作，比如乘法或者加法等等，grad表示方向传播的梯度，data表示取出这个Variabel里面的数据
这就是一个简单的计算图的例子
前面讲了两个操作对象，最后讲一下pytorch里面的模型建立，模型的建立主要依赖于torch.nn，torch.nn包含这个所有神经网络的层的结构
这就是构建所有神经网络的模板，不管你想构建卷积神经网络还是循环神经网络或者是生成对抗网络都依赖于这个结构
原文出处：/news/5.html
更多文章关注：
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。后使用我的收藏没有帐号？
所属分类： &
查看: 13|回复: 0
全职高手为什么这么火 PyTorch 这么火
发表于 5&天前
全职高手为什么这么火 PyTorch 这么火
啪嗒动漫更多精彩内容
回归测试开启 晒截图赢取千元京东卡!
让我们重归MU王国 一起血战最强奇迹!文章不存在_百度首页点击阅读原文
Pytorch 学习笔记之自定义 Module
5月5日 发布，来源：
是一个基于 python 的深度学习库。pytorch 源码库的抽象层次少，结构清晰，代码量适中。相比于非常工程化的 tensorflow，pytorch 是一个更易入手的，非常棒的深度学习框架。
对于系统学习 pytorch，官方提供了非常好的 ，同时还提供了面向深度学习的，同时热心网友分享了更简洁的。
1. overview
不同于 theano，tensorflow 等低层程序库，或者 keras、sonnet 等高层 wrapper，pytorch 是一种自成体系的深度学习库（图1）。
图1. 几种深度学习程序库对比
如图2所示，pytorch 由低层到上层主要有三大块功能模块。
图2. pytorch 主要功能模块
1.1 张量计算引擎（tensor computation）
Tensor 计算引擎，类似 numpy 和 matlab，基本对象是tensor（类比 numpy 中的 ndarray 或 matlab 中的 array）。除提供基于 CPU 的常用操作的实现外，pytorch 还提供了高效的 GPU 实现，这对于深度学习至关重要。
1.2 自动求导机制（autograd）
由于深度学习模型日趋复杂，因此，对自动求导的支持对于学习框架变得必不可少。pytorch 采用了动态求导机制，使用类似方法的框架包括： chainer，dynet。作为对比，theano，tensorflow 采用静态自动求导机制。
1.3 神经网络的高层库（NN）
pytorch 还提供了高层的。对于常用的网络结构，如全连接、卷积、RNN 等。同时，pytorch 还提供了常用的、 及参数。
这里，我们重点关注如何自定义神经网络结构。
2. 自定义 Module
图3. pytorch Module
module 是 pytorch 组织神经网络的基本方式。Module 包含了模型的参数以及计算逻辑。Function 承载了实际的功能，定义了前向和后向的计算逻辑。
下面以最简单的 MLP 网络结构为例，介绍下如何实现自定义网络结构。完整代码可以参见。
2.1 Function
Function 是 pytorch 自动求导机制的核心类。Function 是无参数或者说无状态的，它只负责接收输入，返回相应的输出；对于反向，它接收输出相应的梯度，返回输入相应的梯度。
这里我们只关注如何自定义 Function。Function 的定义见。下面是简化的代码段：
class Function(object):
def forward(self, *input):
raise NotImplementedError
def backward(self, *grad_output):
raise NotImplementedError
forward 和 backward 的输入和输出都是 Tensor 对象。
Function 对象是 callable 的，即可以通过()的方式进行调用。其中调用的输入和输出都为 Variable 对象。下面的示例了如何实现一个 ReLU 激活函数并进行调用：
import torch
from torch.autograd import Function
class ReLUF(Function)：
def forward(self, input):
self.save_for_backward(input)
output = input.clamp(min=0)
return output
def backward(self, output_grad):
input = self.to_save[0]
input_grad = output_grad.clone()
input_grad[input & 0] = 0
return input_grad
if __name__ == "__main__":
from torch.autograd import Variable
torch.manual_seed(1111)
a = torch.randn(2, 3)
va = Variable(a, requires_grad=True)
vb = ReLUF()(va)
print va.data, vb.data
vb.backward(torch.ones(va.size()))
print vb.grad.data, va.grad.data
如果 backward 中需要用到 forward 的输入，需要在 forward 中显式的保存需要的输入。在上面的代码中，forward 利用self.save_for_backward函数，将输入暂时保存，并在 backward 中利用saved_tensors (python tuple 对象) 取出。
显然，forward 的输入应该和 backward 的输入相对应；同时，forward 的输出应该和 backward 的输入相匹配。
由于 Function 可能需要暂存 input tensor，因此，建议不复用 Function 对象，以避免遇到内存提前释放的问题。如所示，forward的每次调用都重新生成一个 ReLUF 对象，而不能在初始化时生成在 forward 中反复调用。
2.2 Module
类似于 Function，Module 对象也是 callable 是，输入和输出也是 Variable。不同的是，Module 是[可以]有参数的。Module 包含两个主要部分：参数及计算逻辑（Function 调用）。由于ReLU激活函数没有参数，这里我们以最基本的全连接层为例来说明如何自定义Module。
全连接层的运算逻辑定义如下 Function:
import torch
from torch.autograd import Function
class LinearF(Function):
def forward(self, input, weight, bias=None):
self.save_for_backward(input, weight, bias)
output = torch.mm(input, weight.t())
if bias is not None:
output += bias.unsqueeze(0).expand_as(output)
return output
def backward(self, grad_output):
input, weight, bias = self.saved_tensors
grad_input = grad_weight = grad_bias = None
if self.needs_input_grad[0]:
grad_input = torch.mm(grad_output, weight)
if self.needs_input_grad[1]:
grad_weight = torch.mm(grad_output.t(), input)
if bias is not None and self.needs_input_grad[2]:
grad_bias = grad_output.sum(0).squeeze(0)
if bias is not None:
return grad_input, grad_weight, grad_bias
return grad_input, grad_weight
为一个元素为 bool 型的 tuple，长度与 forward 的参数数量相同，用来标识各个输入是否输入计算梯度；对于无需梯度的输入，可以减少不必要的计算。
Function（此处为 LinearF） 定义了基本的计算逻辑，Module 只需要在初始化时为参数分配内存空间，并在计算时，将参数传递给相应的 Function 对象。代码如下：
import torch
import torch.nn as nn
class Linear(nn.Module):
def __init__(self, in_features, out_features, bias=True):
super(Linear, self).__init__()
self.in_features = in_features
self.out_features = out_features
self.weight = nn.Parameter(torch.Tensor(out_features, in_features))
self.bias = nn.Parameter(torch.Tensor(out_features))
self.register_parameter('bias', None)
def forward(self, input):
return LinearF()(input, self.weight, self.bias)
需要注意的是，参数是内存空间由 tensor 对象维护，但 tensor 需要包装为一个 对象。Parameter 是
的特殊子类，仅有是不同是 Parameter 默认requires_grad为 True。Varaible 是自动求导机制的核心类，此处暂不介绍，参见。
3. 自定义循环神经网络（RNN）
我们尝试自己定义一个更复杂的 Module ——RNN。这里，我们只定义最基础的 vanilla RNN（图4），基本的计算公式如下：
ht=relu(W?x+U?ht-1)
更复杂的 LSTM、GRU 或者其他变种的实现也非常类似。
3.1 定义 Cell
import torch
from torch.nn import Module, Parameter
class RNNCell(Module):
def __init__(self, input_size, hidden_size):
super(RNNCell, self).__init__()
self.input_size = input_size
self.hidden_size = hidden_size
self.weight_ih = Parameter(torch.Tensor(hidden_size, input_size))
self.weight_hh = Parameter(torch.Tensor(hidden_size, hidden_size))
self.bias_ih = Parameter(torch.Tensor(hidden_size))
self.bias_hh = Parameter(torch.Tensor(hidden_size))
self.reset_parameters()
def reset_parameters(self):
stdv = 1.0 / math.sqrt(self.hidden_size)
for weight in self.parameters():
weight.data.uniform_(-stdv, stdv)
def forward(self, input, h):
output = LinearF()(input, self.weight_ih, self.bias_ih) + LinearF()(h, self.weight_hh, self.bias_hh)
output = ReLUF()(output)
return output
3.2 定义完整的 RNN
import torch
from torch.nn import Module
class RNN(Moudule):
def __init__(self, input_size, hidden_size):
super(RNN, self).__init__()
self.input_size = input_size
self.hidden_size = hidden_size
sef.cell = RNNCell(input_size, hidden_size)
def forward(self, inputs, initial_state):
time_steps = inputs.size(1)
state = initial_state
outputs = []
for t in range(time_steps):
state = self.cell(inputs[:, t, :], state)
outputs.append(state)
return outputs
可运行的完整代码见。
pytorch 的 Module 结构是传承自 torch，这一点也同样被 keras （functional API）所借鉴。 在 caffe 等一些[早期的]深度学习框架中，network 是由于若干 layer ，经由不同的拓扑结构组成的。而在 (pyt)torch 中没有 layer 和 network 是区分，一切都是 callable 的 Module。Module 的调用的输入和输出都是 tensor （由 Variable 封装），用户可以非常自然的构造任意有向无环的网络结构（DAG）。
同时， pytorch 的 autograd 机制封装的比较浅，可以比较容易的定制反传或修改梯度。这对有些算法是非常重要。
总之，仅就自定义算法而言，pytorch 是一个非常优雅的深度学习框架。
明天提醒我
我要该，理由是：
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）