Python：机器学习模块PyTorch【上】

点击访问：PyTorch中文API应用具体代码地址

自动求导机制

本说明将概述Autograd如何工作并记录操作。了解这些并不是绝对必要的，但我们建议您熟悉它，因为它将帮助您编写更高效，更简洁的程序，并可帮助您进行调试。

从后向中排除子图

每个变量都有两个标志：requires_grad和volatile。它们都允许从梯度计算中精细地排除子图，并可以提高效率。

requires_grad

如果有一个单一的输入操作需要梯度，它的输出也需要梯度。相反，只有所有输入都不需要梯度，输出才不需要。如果其中所有的变量都不需要梯度进行，后向计算不会在子图中执行。

>>> x = Variable(torch.randn(5, 5))
>>> y = Variable(torch.randn(5, 5))
>>> z = Variable(torch.randn(5, 5), requires_grad=True)
>>> a = x + y
>>> a.requires_grad
False
>>> b = a + z
>>> b.requires_grad
True

这个标志特别有用，当您想要冻结部分模型时，或者您事先知道不会使用某些参数的梯度。例如，如果要对预先训练的CNN进行优化，只要切换冻结模型中的requires_grad标志就足够了，直到计算到最后一层才会保存中间缓冲区，其中的仿射变换将使用需要梯度的权重并且网络的输出也将需要它们。

model = torchvision.models.resnet18(pretrained=True)
for param in model.parameters():
    param.requires_grad = False
# Replace the last fully-connected layer
# Parameters of newly constructed modules have requires_grad=True by default
model.fc = nn.Linear(512, 100)

# Optimize only the classifier
optimizer = optim.SGD(model.fc.parameters(), lr=1e-2, momentum=0.9)

volatile

纯粹的inference模式下推荐使用volatile，当你确定你甚至不会调用.backward()时。它比任何其他自动求导的设置更有效——它将使用绝对最小的内存来评估模型。volatile也决定了require_grad is False。

volatile不同于require_grad的传递。如果一个操作甚至只有有一个volatile的输入，它的输出也将是volatile。Volatility比“不需要梯度”更容易传递——只需要一个volatile的输入即可得到一个volatile的输出，相对的，需要所有的输入“不需要梯度”才能得到不需要梯度的输出。使用volatile标志，您不需要更改模型参数的任何设置来用于inference。创建一个volatile的输入就够了，这将保证不会保存中间状态。

>>> regular_input = Variable(torch.randn(5, 5))
>>> volatile_input = Variable(torch.randn(5, 5), volatile=True)
>>> model = torchvision.models.resnet18(pretrained=True)
>>> model(regular_input).requires_grad
True
>>> model(volatile_input).requires_grad
False
>>> model(volatile_input).volatile
True
>>> model(volatile_input).creator is None
True

自动求导如何编码历史信息

每个变量都有一个.creator属性，它指向把它作为输出的函数。这是一个由Function对象作为节点组成的有向无环图（DAG）的入口点，它们之间的引用就是图的边。每次执行一个操作时，一个表示它的新Function就被实例化，它的forward()方法被调用，并且它输出的Variable的创建者被设置为这个Function。然后，通过跟踪从任何变量到叶节点的路径，可以重建创建数据的操作序列，并自动计算梯度。

需要注意的一点是，整个图在每次迭代时都是从头开始重新创建的，这就允许使用任意的Python控制流语句，这样可以在每次迭代时改变图的整体形状和大小。在启动训练之前不必对所有可能的路径进行编码—— what you run is what you differentiate.

Variable上的In-place操作

在自动求导中支持in-place操作是一件很困难的事情，我们在大多数情况下都不鼓励使用它们。Autograd的缓冲区释放和重用非常高效，并且很少场合下in-place操作能实际上明显降低内存的使用量。除非您在内存压力很大的情况下，否则您可能永远不需要使用它们。

限制in-place操作适用性主要有两个原因：

１．覆盖梯度计算所需的值。这就是为什么变量不支持log_。它的梯度公式需要原始输入，而虽然通过计算反向操作可以重新创建它，但在数值上是不稳定的，并且需要额外的工作，这往往会与使用这些功能的目的相悖。

２．每个in-place操作实际上需要实现重写计算图。不合适的版本只需分配新对象并保留对旧图的引用，而in-place操作则需要将所有输入的creator更改为表示此操作的Function。这就比较棘手，特别是如果有许多变量引用相同的存储（例如通过索引或转置创建的），并且如果被修改输入的存储被任何其他Variable引用，则in-place函数实际上会抛出错误。

In-place正确性检查

每个变量保留有version counter，它每次都会递增，当在任何操作中被使用时。当Function保存任何用于后向的tensor时，还会保存其包含变量的version counter。一旦访问self.saved_tensors，它将被检查，如果它大于保存的值，则会引起错误。

CUDA语义

torch.cuda会记录当前选择的GPU，并且分配的所有CUDA张量将在上面创建。可以使用torch.cuda.device上下文管理器更改所选设备。

但是，一旦张量被分配，您可以直接对其进行操作，而不考虑所选择的设备，结果将始终放在与张量相同的设备上。

默认情况下，不支持跨GPU操作，唯一的例外是copy_()。 除非启用对等存储器访问，否则对分布不同设备上的张量任何启动操作的尝试都将会引发错误。

下面你可以找到一个展示如下的小例子：

x = torch.cuda.FloatTensor(1)
# x.get_device() == 0
y = torch.FloatTensor(1).cuda()
# y.get_device() == 0

with torch.cuda.device(1):
    # allocates a tensor on GPU 1
    a = torch.cuda.FloatTensor(1)

    # transfers a tensor from CPU to GPU 1
    b = torch.FloatTensor(1).cuda()
    # a.get_device() == b.get_device() == 1

    c = a + b
    # c.get_device() == 1

    z = x + y
    # z.get_device() == 0

    # even within a context, you can give a GPU id to the .cuda call
    d = torch.randn(2).cuda(2)
    # d.get_device() == 2

最佳实践

使用固定的内存缓冲区

当副本来自固定（页锁）内存时，主机到GPU的复制速度要快很多。CPU张量和存储开放了一个pin_memory()方法，它返回该对象的副本，而它的数据放在固定区域中。

另外，一旦固定了张量或存储，就可以使用异步的GPU副本。只需传递一个额外的async=True参数到cuda()的调用。这可以用于将数据传输与计算重叠。

通过将pin_memory=True传递给其构造函数，可以使DataLoader将batch返回到固定内存中。

使用 nn.DataParallel 替代 multiprocessing

大多数涉及批量输入和多个GPU的情况应默认使用DataParallel来使用多个GPU。尽管有GIL的存在，单个python进程也可能使多个GPU饱和。

从0.1.9版本开始，大量的GPU(8+)可能未被充分利用。然而，这是一个已知的问题，也正在积极开发。和往常一样，测试你的用例吧。

调用multiprocessing来利用CUDA模型存在重要的注意事项；使用具有多处理功能的CUDA模型有重要的注意事项; 除非就是需要谨慎地满足数据处理需求，否则您的程序很可能会出现错误或未定义的行为。

扩展PyTorch

扩展 torch.autograd

如果你想要添加一个新的 Operation 到autograd的话，你的Operation需要继承 class Function。autograd使用Function计算结果和梯度，同时编码 operation的历史。每个新的 operation(function) 都需要实现三个方法：

• __init__ (optional) - 如果你的operation包含非Variable参数，那么就将其作为__init__的参数传入到operation中。例如：AddConstant Function加一个常数，Transpose Function需要指定哪两个维度需要交换。如果你的operation不需要额外的参数，你可以忽略__init__。

• forward() - 在里面写执行此operation的代码。可以有任意数量的参数。如果你对某些参数指定了默认值，则这些参数是可传可不传的。记住：forward()的参数只能是Variable。函数的返回值既可以是 Variable也可以是Variables的tuple。同时，请参考 Function[function]的 doc，查阅有哪些 方法是只能在forward中调用的。

• backward() - 梯度计算公式。 参数的个数和forward返回值的个数一样，每个参数代表传回到此operation的梯度. backward()的返回值的个数应该和此operation输入的个数一样，每个返回值对应了输入值的梯度。如果operation的输入不需要梯度，或者不可导，你可以返回None。 如果forward()存在可选参数，你可以返回比输入更多的梯度，只是返回的是None。

下面是 Linear 的实现代码：

# Inherit from Function
class Linear(Function):

    # bias is an optional argument
    def forward(self, input, weight, bias=None):
        self.save_for_backward(input, weight, bias)
        output = input.mm(weight.t())
        if bias is not None:
            output += bias.unsqueeze(0).expand_as(output)
        return output

    # This function has only a single output, so it gets only one gradient
    def backward(self, grad_output):
        # This is a pattern that is very convenient - at the top of backward
        # unpack saved_tensors and initialize all gradients w.r.t. inputs to
        # None. Thanks to the fact that additional trailing Nones are
        # ignored, the return statement is simple even when the function has
        # optional inputs.
        input, weight, bias = self.saved_tensors
        grad_input = grad_weight = grad_bias = None

        # These needs_input_grad checks are optional and there only to
        # improve efficiency. If you want to make your code simpler, you can
        # skip them. Returning gradients for inputs that don't require it is
        # not an error.
        if self.needs_input_grad[0]:
            grad_input = grad_output.mm(weight)
        if self.needs_input_grad[1]:
            grad_weight = grad_output.t().mm(input)
        if bias is not None and self.needs_input_grad[2]:
            grad_bias = grad_output.sum(0).squeeze(0)

        return grad_input, grad_weight, grad_bias

现在，为了可以更简单的使用自定义的operation，我们建议将其用一个简单的 helper function 包装起来。 functions:

def linear(input, weight, bias=None):
    # First braces create a Function object. Any arguments given here
    # will be passed to __init__. Second braces will invoke the __call__
    # operator, that will then use forward() to compute the result and
    # return it.
    return Linear()(input, weight, bias)

你可能想知道你刚刚实现的 backward方法是否正确的计算了梯度。你可以使用 小的有限的差分进行数值估计。

from torch.autograd import gradcheck

# gradchek takes a tuple of tensor as input, check if your gradient
# evaluated with these tensors are close enough to numerical
# approximations and returns True if they all verify this condition.
input = (Variable(torch.randn(20,20).double(), requires_grad=True),)
test = gradcheck.gradcheck(Linear(), input, eps=1e-6, atol=1e-4)
print(test)

扩展 torch.nn

nn 包含两种接口 - modules和他们的functional版本。通过这两个接口，你都可以扩展nn。但是我们建议，在扩展layer的时候，使用modules， 因为modules保存着参数和buffer。如果不需要参数的话，那么建议使用functional(激活函数，pooling，这些都不需要参数)。

增加一个operation的 functional版本已经在上面一节介绍完毕。

增加一个模块(module)。 由于nn重度使用autograd。所以，添加一个新module需要实现一个 用来执行 计算 和 计算梯度 的Function。从现在开始，假定我们想要实现一个Linear module，记得之前我们已经实现了一个Linear Funciton。 只需要很少的代码就可以完成这个工作。 现在，我们需要实现两个方法：

• __init__ (optional) - 输入参数，例如kernel sizes, numbers of features, 等等。同时初始化 parameters和buffers。

• forward() - 实例化一个执行operation的Function，使用它执行operation。和functional wrapper(上面实现的那个简单的wrapper)十分类似。

Linear module实现代码:

class Linear(nn.Module):
    def __init__(self, input_features, output_features, bias=True):
        self.input_features = input_features
        self.output_features = output_features

        # nn.Parameter is a special kind of Variable, that will get
        # automatically registered as Module's parameter once it's assigned
        # as an attribute. Parameters and buffers need to be registered, or
        # they won't appear in .parameters() (doesn't apply to buffers), and
        # won't be converted when e.g. .cuda() is called. You can use
        # .register_buffer() to register buffers.
        # nn.Parameters can never be volatile and, different than Variables,
        # they require gradients by default.
        self.weight = nn.Parameter(torch.Tensor(input_features, output_features))
        if bias:
            self.bias = nn.Parameter(torch.Tensor(output_features))
        else:
            # You should always register all possible parameters, but the
            # optional ones can be None if you want.
            self.register_parameter('bias', None)

        # Not a very smart way to initialize weights
        self.weight.data.uniform_(-0.1, 0.1)
        if bias is not None:
            self.bias.data.uniform_(-0.1, 0.1)

    def forward(self, input):
        # See the autograd section for explanation of what happens here.
        return Linear()(input, self.weight, self.bias)
        #注意这个Linear是之前实现过的Linear

编写自定义C扩展

Coming soon. For now you can find an example at GitHub.

多进程最佳实践

torch.multiprocessing是Pythonmultiprocessing的替代品。它支持完全相同的操作，但扩展了它以便通过multiprocessing.Queue发送的所有张量将其数据移动到共享内存中，并且只会向其他进程发送一个句柄。

Note

当Variable发送到另一个进程时，Variable.data和Variable.grad.data都将被共享。

这允许实现各种训练方法，如Hogwild，A3C或需要异步操作的任何其他方法。

共享CUDA张量

仅在Python 3中使用spawn或forkserver启动方法才支持在进程之间共享CUDA张量。Python 2中的multiprocessing只能使用fork创建子进程，并且不被CUDA运行时所支持。

Warning

CUDA API要求导出到其他进程的分配，只要它们被使用就要一直保持有效。您应该小心，确保您共享的CUDA张量只要有必要就不要超出范围。这不是共享模型参数的问题，但传递其他类型的数据应该小心。注意，此限制不适用于共享CPU内存。

最佳实践和提示

避免和抵制死锁

当一个新进程被产生时，有很多事情可能会出错，最常见的死锁原因是后台线程。如果有任何线程持有锁或导入模块，并且fork被调用，则子进程很可能处于损坏的状态，并以不同的方式死锁或失败。注意，即使您没有，Python内置的库也可能会这样做 —— 不需要看得比multiprocessing更远。multiprocessing.Queue实际上是一个非常复杂的类，它产生用于序列化，发送和接收对象的多个线程，它们也可能引起上述问题。如果您发现自己处于这种情况，请尝试使用multiprocessing.queues.SimpleQueue，这不会使用任何其他线程。

我们正在竭尽全力把它设计得更简单，并确保这些死锁不会发生，但有些事情无法控制。如果有任何问题您无法一时无法解决，请尝试在论坛上提出，我们将看看是否可以解决问题。

重用经过队列的缓冲区

记住每次将Tensor放入multiprocessing.Queue时，必须将其移动到共享内存中。如果它已经被共享，它是一个无效的操作，否则会产生一个额外的内存副本，这会减缓整个进程。即使你有一个进程池来发送数据到一个进程，使它返回缓冲区 —— 这几乎是免费的，并且允许你在发送下一个batch时避免产生副本。

异步多进程训练（例如Hogwild）

使用torch.multiprocessing，可以异步地训练模型，参数可以一直共享，也可以定期同步。在第一种情况下，我们建议发送整个模型对象，而在后者中，我们建议只发送state_dict()。

我们建议使用multiprocessing.Queue来在进程之间传递各种PyTorch对象。例如， 当使用fork启动方法时，可能会继承共享内存中的张量和存储器，但这是非常容易出错的，应谨慎使用，而且只能由高级用户使用。队列虽然有时是一个较不优雅的解决方案，但基本上能在所有情况下正常工作。

Warning 你应该注意有关全局语句，它们没有被if __name__ == '__main__'保护。如果使用与fork不同的启动方法，则它们将在所有子进程中执行。

Hogwild

在examples repository中可以找到具体的Hogwild实现，可以展示代码的整体结构。下面也有一个小例子：

import torch.multiprocessing as mp
from model import MyModel

def train(model):
    # Construct data_loader, optimizer, etc.
    for data, labels in data_loader:
        optimizer.zero_grad()
        loss_fn(model(data), labels).backward()
        optimizer.step()  # This will update the shared parameters

if __name__ == '__main__':
    num_processes = 4
    model = MyModel()
    # NOTE: this is required for the ``fork`` method to work
    model.share_memory()
    processes = []
    for rank in range(num_processes):
        p = mp.Process(target=train, args=(model,))
        p.start()
        processes.append(p)
    for p in processes:
      p.join()

序列化语义

最佳实践

保存模型的推荐方法

这主要有两种方法序列化和恢复模型。

第一种（推荐）只保存和加载模型参数：

torch.save(the_model.state_dict(), PATH)

然后：

the_model = TheModelClass(*args, **kwargs)
the_model.load_state_dict(torch.load(PATH))

第二种保存和加载整个模型：

torch.save(the_model, PATH)

然后：

the_model = torch.load(PATH)

然而，在这种情况下，序列化的数据被绑定到特定的类和固定的目录结构，所以当在其他项目中使用时，或者在一些严重的重构器之后它可能会以各种方式break。

torch

包 torch 包含了多维张量的数据结构以及基于其上的多种数学操作。另外，它也提供了多种工具，其中一些可以更有效地对张量和任意类型进行序列化。

它有CUDA 的对应实现，可以在NVIDIA GPU上进行张量运算(计算能力>=2.0)。

张量 Tensors

torch.is_tensor[source]

torch.is_tensor(obj)

如果obj 是一个pytorch张量，则返回True

• 参数： obj (Object) – 判断对象

---

torch.is_storage [source]

torch.is_storage(obj)

如何obj 是一个pytorch storage对象，则返回True

• 参数： input (Object) – 判断对象

---

torch.set_default_tensor_type[source]

torch.set_default_tensor_type(t)

---

torch.numel

torch.numel(input)->int

返回input 张量中的元素个数

• 参数: input (Tensor) – 输入张量

例子:

>>> a = torch.randn(1,2,3,4,5)
>>> torch.numel(a)
120
>>> a = torch.zeros(4,4)
>>> torch.numel(a)
16

---

torch.set_printoptions[source]

torch.set_printoptions(precision=None, threshold=None, edgeitems=None, linewidth=None, profile=None)

设置打印选项。 完全参考自 Numpy。

参数:

• precision – 浮点数输出的精度位数 (默认为8 )
• threshold – 阈值，触发汇总显示而不是完全显示(repr)的数组元素的总数 （默认为1000）
• edgeitems – 汇总显示中，每维（轴）两端显示的项数（默认值为3）
• linewidth – 用于插入行间隔的每行字符数（默认为80）。Thresholded matricies will ignore this parameter.
• profile – pretty打印的完全默认值。 可以覆盖上述所有选项 (默认为short, full)

创建操作 Creation Ops

torch.eye

torch.eye(n, m=None, out=None)

返回一个2维张量，对角线位置全1，其它位置全0

参数:

• n (int ) – 行数
• m (int, optional) – 列数.如果为None,则默认为n
• out (Tensor, optinal) - Output tensor

返回值: 对角线位置全1，其它位置全0的2维张量

返回值类型: Tensor

例子:

>>> torch.eye(3)
 1  0  0
 0  1  0
 0  0  1
[torch.FloatTensor of size 3x3]

---

from_numpy

torch.from_numpy(ndarray) → Tensor

Numpy桥，将numpy.ndarray 转换为pytorch的 Tensor。 返回的张量tensor和numpy的ndarray共享同一内存空间。修改一个会导致另外一个也被修改。返回的张量不能改变大小。

例子:

>>> a = numpy.array([1, 2, 3])
>>> t = torch.from_numpy(a)
>>> t
torch.LongTensor([1, 2, 3])
>>> t[0] = -1
>>> a
array([-1,  2,  3])

torch.linspace

torch.linspace(start, end, steps=100, out=None) → Tensor

返回一个1维张量，包含在区间start 和 end 上均匀间隔的steps个点。 输出1维张量的长度为steps。

参数:

• start (float) – 序列的起始点
• end (float) – 序列的最终值
• steps (int) – 在start 和 end间生成的样本数
• out (Tensor, optional) – 结果张量

例子:

>>> torch.linspace(3, 10, steps=5)

  3.0000
  4.7500
  6.5000
  8.2500
 10.0000
[torch.FloatTensor of size 5]

>>> torch.linspace(-10, 10, steps=5)

-10
 -5
  0
  5
 10
[torch.FloatTensor of size 5]

>>> torch.linspace(start=-10, end=10, steps=5)

-10
 -5
  0
  5
 10
[torch.FloatTensor of size 5]

---

torch.logspace

torch.logspace(start, end, steps=100, out=None) → Tensor

返回一个1维张量，包含在区间 10的start次方到10的end次方上以对数刻度均匀间隔的steps个点。 输出1维张量的长度为steps。

参数:

• start (float) – 序列的起始点
• end (float) – 序列的最终值
• steps (int) – 在start 和 end间生成的样本数
• out (Tensor, optional) – 结果张量

例子:

>>> torch.logspace(start=-10, end=10, steps=5)

 1.0000e-10
 1.0000e-05
 1.0000e+00
 1.0000e+05
 1.0000e+10
[torch.FloatTensor of size 5]

>>> torch.logspace(start=0.1, end=1.0, steps=5)

  1.2589
  2.1135
  3.5481
  5.9566
 10.0000
[torch.FloatTensor of size 5]

torch.ones

torch.ones(*sizes, out=None) → Tensor

返回一个全为1 的张量，形状由可变参数sizes定义。

参数:

• sizes (int…) – 整数序列，定义了输出形状
• out (Tensor, optional) – 结果张量 例子:

>>> torch.ones(2, 3)

 1  1  1
 1  1  1
[torch.FloatTensor of size 2x3]

>>> torch.ones(5)

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

---

torch.rand

torch.rand(*sizes, out=None) → Tensor

返回一个张量，包含了从区间[0,1)的均匀分布中抽取的一组随机数，形状由可变参数sizes 定义。

参数:

• sizes (int…) – 整数序列，定义了输出形状
• out (Tensor, optinal) - 结果张量 例子：

>>> torch.rand(4)

 0.9193
 0.3347
 0.3232
 0.7715
[torch.FloatTensor of size 4]

>>> torch.rand(2, 3)

 0.5010  0.5140  0.0719
 0.1435  0.5636  0.0538
[torch.FloatTensor of size 2x3]

---

torch.randn

torch.randn(*sizes, out=None) → Tensor

返回一个张量，包含了从标准正态分布(均值为0，方差为 1，即高斯白噪声)中抽取一组随机数，形状由可变参数sizes定义。 参数:

• sizes (int…) – 整数序列，定义了输出形状
• out (Tensor, optinal) - 结果张量

例子：:

>>> torch.randn(4)

-0.1145
 0.0094
-1.1717
 0.9846
[torch.FloatTensor of size 4]

>>> torch.randn(2, 3)

 1.4339  0.3351 -1.0999
 1.5458 -0.9643 -0.3558
[torch.FloatTensor of size 2x3]

---

torch.randperm

torch.randperm(n, out=None) → LongTensor

给定参数n，返回一个从0 到n -1 的随机整数排列。

参数:

• n (int) – 上边界(不包含)

例子：

>>> torch.randperm(4)

 2
 1
 3
 0
[torch.LongTensor of size 4]

---

torch.arange

torch.arange(start, end, step=1, out=None) → Tensor

参数:

• start (float) – 序列的起始点
• end (float) – 序列的终止点
• step (float) – 相邻点的间隔大小
• out (Tensor, optional) – 结果张量

例子：

>>> torch.arange(1, 4)

 1
 2
 3
[torch.FloatTensor of size 3]

>>> torch.arange(1, 2.5, 0.5)

 1.0000
 1.5000
 2.0000
[torch.FloatTensor of size 3]

---

torch.range

torch.range(start, end, step=1, out=None) → Tensor

警告：建议使用函数 torch.arange()

参数:

• start (float) – 序列的起始点
• end (float) – 序列的最终值
• step (int) – 相邻点的间隔大小
• out (Tensor, optional) – 结果张量

例子：

>>> torch.range(1, 4)

 1
 2
 3
 4
[torch.FloatTensor of size 4]

>>> torch.range(1, 4, 0.5)

 1.0000
 1.5000
 2.0000
 2.5000
 3.0000
 3.5000
 4.0000
[torch.FloatTensor of size 7]

---

torch.zeros

torch.zeros(*sizes, out=None) → Tensor

返回一个全为标量 0 的张量，形状由可变参数sizes 定义。

参数:

• sizes (int…) – 整数序列，定义了输出形状
• out (Tensor, optional) – 结果张量

例子：

>>> torch.zeros(2, 3)

 0  0  0
 0  0  0
[torch.FloatTensor of size 2x3]

>>> torch.zeros(5)

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

---

索引,切片,连接,换位Indexing, Slicing, Joining, Mutating Ops

torch.cat

torch.cat(inputs, dimension=0) → Tensor

在给定维度上对输入的张量序列seq 进行连接操作。

torch.cat()可以看做 torch.split() 和 torch.chunk()的反操作。 cat() 函数可以通过下面例子更好的理解。

参数:

• inputs (sequence of Tensors) – 可以是任意相同Tensor 类型的python 序列
• dimension (int, optional) – 沿着此维连接张量序列。

例子：

>>> x = torch.randn(2, 3)
>>> x

 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 2x3]

>>> torch.cat((x, x, x), 0)

 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 6x3]

>>> torch.cat((x, x, x), 1)

 0.5983 -0.0341  2.4918  0.5983 -0.0341  2.4918  0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735  1.5981 -0.5265 -0.8735  1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 2x9]

torch.chunk

torch.chunk(tensor, chunks, dim=0)

在给定维度(轴)上将输入张量进行分块儿。

参数:

• tensor (Tensor) – 待分块的输入张量
• chunks (int) – 分块的个数
• dim (int) – 沿着此维度进行分块

torch.gather

torch.gather(input, dim, index, out=None) → Tensor

沿给定轴dim，将输入索引张量index指定位置的值进行聚合。

对一个3维张量，输出可以定义为：

out[i][j][k] = tensor[index[i][j][k]][j][k]  # dim=0
out[i][j][k] = tensor[i][index[i][j][k]][k]  # dim=1
out[i][j][k] = tensor[i][j][index[i][j][k]]  # dim=3

例子：

>>> t = torch.Tensor([[1,2],[3,4]])
>>> torch.gather(t, 1, torch.LongTensor([[0,0],[1,0]]))
 1  1
 4  3
[torch.FloatTensor of size 2x2]

参数:

• input (Tensor) – 源张量
• dim (int) – 索引的轴
• index (LongTensor) – 聚合元素的下标
• out (Tensor, optional) – 目标张量

torch.index_select

torch.index_select(input, dim, index, out=None) → Tensor

沿着指定维度对输入进行切片，取index中指定的相应项(index为一个LongTensor)，然后返回到一个新的张量， 返回的张量与原始张量_Tensor_有相同的维度(在指定轴上)。

注意： 返回的张量不与原始张量共享内存空间。

参数:

• input (Tensor) – 输入张量
• dim (int) – 索引的轴
• index (LongTensor) – 包含索引下标的一维张量
• out (Tensor, optional) – 目标张量

例子：

>>> x = torch.randn(3, 4)
>>> x

 1.2045  2.4084  0.4001  1.1372
 0.5596  1.5677  0.6219 -0.7954
 1.3635 -1.2313 -0.5414 -1.8478
[torch.FloatTensor of size 3x4]

>>> indices = torch.LongTensor([0, 2])
>>> torch.index_select(x, 0, indices)

 1.2045  2.4084  0.4001  1.1372
 1.3635 -1.2313 -0.5414 -1.8478
[torch.FloatTensor of size 2x4]

>>> torch.index_select(x, 1, indices)

 1.2045  0.4001
 0.5596  0.6219
 1.3635 -0.5414
[torch.FloatTensor of size 3x2]

torch.masked_select

torch.masked_select(input, mask, out=None) → Tensor

根据掩码张量mask中的二元值，取输入张量中的指定项( mask为一个 ByteTensor)，将取值返回到一个新的1D张量，

张量 mask须跟input张量有相同数量的元素数目，但形状或维度不需要相同。 注意： 返回的张量不与原始张量共享内存空间。

参数:

• input (Tensor) – 输入张量
• mask (ByteTensor) – 掩码张量，包含了二元索引值
• out (Tensor, optional) – 目标张量

例子：

>>> x = torch.randn(3, 4)
>>> x

 1.2045  2.4084  0.4001  1.1372
 0.5596  1.5677  0.6219 -0.7954
 1.3635 -1.2313 -0.5414 -1.8478
[torch.FloatTensor of size 3x4]

>>> indices = torch.LongTensor([0, 2])
>>> torch.index_select(x, 0, indices)

 1.2045  2.4084  0.4001  1.1372
 1.3635 -1.2313 -0.5414 -1.8478
[torch.FloatTensor of size 2x4]

>>> torch.index_select(x, 1, indices)

 1.2045  0.4001
 0.5596  0.6219
 1.3635 -0.5414
[torch.FloatTensor of size 3x2]

torch.nonzero

torch.nonzero(input, out=None) → LongTensor

返回一个包含输入input中非零元素索引的张量。输出张量中的每行包含输入中非零元素的索引。

如果输入input有n维，则输出的索引张量output的形状为 z x n, 这里 z 是输入张量input中所有非零元素的个数。

参数:

• input (Tensor) – 源张量
• out (LongTensor, optional) – 包含索引值的结果张量

例子：

>>> torch.nonzero(torch.Tensor([1, 1, 1, 0, 1]))

 0
 1
 2
 4
[torch.LongTensor of size 4x1]

>>> torch.nonzero(torch.Tensor([[0.6, 0.0, 0.0, 0.0],
...                             [0.0, 0.4, 0.0, 0.0],
...                             [0.0, 0.0, 1.2, 0.0],
...                             [0.0, 0.0, 0.0,-0.4]]))

 0  0
 1  1
 2  2
 3  3
[torch.LongTensor of size 4x2]

torch.split

torch.split(tensor, split_size, dim=0)

将输入张量分割成相等形状的chunks（如果可分）。 如果沿指定维的张量形状大小不能被split_size 整分， 则最后一个分块会小于其它分块。

参数:

• tensor (Tensor) – 待分割张量
• split_size (int) – 单个分块的形状大小
• dim (int) – 沿着此维进行分割

torch.squeeze

torch.squeeze(input, dim=None, out=None)

注意： 返回张量与输入张量共享内存，所以改变其中一个的内容会改变另一个。

参数:

• input (Tensor) – 输入张量
• dim (int, optional) – 如果给定，则input只会在给定维度挤压
• out (Tensor, optional) – 输出张量

例子：

>>> x = torch.zeros(2,1,2,1,2)
>>> x.size()
(2L, 1L, 2L, 1L, 2L)
>>> y = torch.squeeze(x)
>>> y.size()
(2L, 2L, 2L)
>>> y = torch.squeeze(x, 0)
>>> y.size()
(2L, 1L, 2L, 1L, 2L)
>>> y = torch.squeeze(x, 1)
>>> y.size()
(2L, 2L, 1L, 2L)

torch.stack[source]

torch.stack(sequence, dim=0)

沿着一个新维度对输入张量序列进行连接。 序列中所有的张量都应该为相同形状。

参数:

• sqequence (Sequence) – 待连接的张量序列
• dim (int) – 插入的维度。必须介于 0 与 待连接的张量序列数之间。

torch.t

torch.t(input, out=None) → Tensor

输入一个矩阵（2维张量），并转置0, 1维。 可以被视为函数transpose(input, 0, 1)的简写函数。

参数:

• input (Tensor) – 输入张量
• out (Tensor, optional) – 结果张量

>>> x = torch.randn(2, 3)
>>> x

 0.4834  0.6907  1.3417
-0.1300  0.5295  0.2321
[torch.FloatTensor of size 2x3]

>>> torch.t(x)

 0.4834 -0.1300
 0.6907  0.5295
 1.3417  0.2321
[torch.FloatTensor of size 3x2]

torch.transpose

torch.transpose(input, dim0, dim1, out=None) → Tensor

返回输入矩阵input的转置。交换维度dim0和dim1。 输出张量与输入张量共享内存，所以改变其中一个会导致另外一个也被修改。

参数:

• input (Tensor) – 输入张量
• dim0 (int) – 转置的第一维
• dim1 (int) – 转置的第二维

>>> x = torch.randn(2, 3)
>>> x

 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 2x3]

>>> torch.transpose(x, 0, 1)

 0.5983  1.5981
-0.0341 -0.5265
 2.4918 -0.8735
[torch.FloatTensor of size 3x2]

torch.unbind

torch.unbind(tensor, dim=0)[source]

移除指定维后，返回一个元组，包含了沿着指定维切片后的各个切片

参数:

• tensor (Tensor) – 输入张量
• dim (int) – 删除的维度

torch.unsqueeze

torch.unsqueeze(input, dim, out=None)

返回一个新的张量，对输入的制定位置插入维度 1

注意： 返回张量与输入张量共享内存，所以改变其中一个的内容会改变另一个。

参数:

• tensor (Tensor) – 输入张量
• dim (int) – 插入维度的索引
• out (Tensor, optional) – 结果张量

>>> x = torch.Tensor([1, 2, 3, 4])
>>> torch.unsqueeze(x, 0)
 1  2  3  4
[torch.FloatTensor of size 1x4]
>>> torch.unsqueeze(x, 1)
 1
 2
 3
 4
[torch.FloatTensor of size 4x1]

---

随机抽样 Random sampling

torch.manual_seed

torch.manual_seed(seed)

设定生成随机数的种子，并返回一个 torch._C.Generator 对象.

参数: seed (int or long) – 种子.

torch.initial_seed

torch.initial_seed()

返回生成随机数的原始种子值（python long）。

torch.get_rng_state

torch.get_rng_state()[source]

返回随机生成器状态(ByteTensor)

torch.set_rng_state

torch.set_rng_state(new_state)[source]

设定随机生成器状态 参数: new_state (torch.ByteTensor) – 期望的状态

torch.default_generator

torch.default_generator = <torch._C.Generator object>

torch.bernoulli

torch.bernoulli(input, out=None) → Tensor

从伯努利分布中抽取二元随机数(0 或者 1)。

输出张量的第*i个元素值， 将会以输入张量的第i*个概率值等于1。

返回值将会是与输入相同大小的张量，每个值为0或者1 参数:

• input (Tensor) – 输入为伯努利分布的概率值
• out (Tensor, optional) – 输出张量(可选)

例子：

>>> a = torch.Tensor(3, 3).uniform_(0, 1) # generate a uniform random matrix with range [0, 1]
>>> a

 0.7544  0.8140  0.9842
 0.5282  0.0595  0.6445
 0.1925  0.9553  0.9732
[torch.FloatTensor of size 3x3]

>>> torch.bernoulli(a)

 1  1  1
 0  0  1
 0  1  1
[torch.FloatTensor of size 3x3]

>>> a = torch.ones(3, 3) # probability of drawing "1" is 1
>>> torch.bernoulli(a)

 1  1  1
 1  1  1
 1  1  1
[torch.FloatTensor of size 3x3]

>>> a = torch.zeros(3, 3) # probability of drawing "1" is 0
>>> torch.bernoulli(a)

 0  0  0
 0  0  0
 0  0  0
[torch.FloatTensor of size 3x3]

---

torch.multinomial

torch.multinomial(input, num_samples,replacement=False, out=None) → LongTensor

返回一个张量，每行包含从input相应行中定义的多项分布中抽取的num_samples个样本。

[注意]:输入input每行的值不需要总和为1 (这里我们用来做权重)，但是必须非负且总和不能为0。

当抽取样本时，依次从左到右排列(第一个样本对应第一列)。

如果参数replacement 为 True, 则样本抽取可以重复。否则，一个样本在每行不能被重复抽取。

参数num_samples必须小于input长度(即，input的列数，如果是input是一个矩阵)。

参数:

• input (Tensor) – 包含概率值的张量
• num_samples (int) – 抽取的样本数
• replacement (bool, optional) – 布尔值，决定是否能重复抽取
• out (Tensor, optional) – 结果张量

例子：

>>> weights = torch.Tensor([0, 10, 3, 0]) # create a Tensor of weights
>>> torch.multinomial(weights, 4)

 1
 2
 0
 0
[torch.LongTensor of size 4]

>>> torch.multinomial(weights, 4, replacement=True)

 1
 2
 1
 2
[torch.LongTensor of size 4]

torch.normal()

torch.normal(means, std, out=None)

返回一个张量，包含从给定参数means,std的离散正态分布中抽取随机数。 均值means是一个张量，包含每个输出元素相关的正态分布的均值。 std是一个张量，包含每个输出元素相关的正态分布的标准差。 均值和标准差的形状不须匹配，但每个张量的元素个数须相同。

参数:

• means (Tensor) – 均值
• std (Tensor) – 标准差
• out (Tensor) – 可选的输出张量

torch.normal(means=torch.arange(1, 11), std=torch.arange(1, 0, -0.1))

 1.5104
 1.6955
 2.4895
 4.9185
 4.9895
 6.9155
 7.3683
 8.1836
 8.7164
 9.8916
[torch.FloatTensor of size 10]

torch.normal(mean=0.0, std, out=None)

与上面函数类似，所有抽取的样本共享均值。

参数:

• means (Tensor,optional) – 所有分布均值
• std (Tensor) – 每个元素的标准差
• out (Tensor) – 可选的输出张量

例子:

>>> torch.normal(mean=0.5, std=torch.arange(1, 6))

  0.5723
  0.0871
 -0.3783
 -2.5689
 10.7893
[torch.FloatTensor of size 5]

torch.normal(means, std=1.0, out=None)

与上面函数类似，所有抽取的样本共享标准差。

参数:

• means (Tensor) – 每个元素的均值
• std (float, optional) – 所有分布的标准差
• out (Tensor) – 可选的输出张量

例子:

>>> torch.normal(means=torch.arange(1, 6))

 1.1681
 2.8884
 3.7718
 2.5616
 4.2500
[torch.FloatTensor of size 5]

---

序列化 Serialization

torch.saves[source]

torch.save(obj, f, pickle_module=<module 'pickle' from '/home/jenkins/miniconda/lib/python3.5/pickle.py'>, pickle_protocol=2)

保存一个对象到一个硬盘文件上 参考: Recommended approach for saving a model 参数：

• obj – 保存对象
• f － 类文件对象 (返回文件描述符)或一个保存文件名的字符串
• pickle_module – 用于pickling元数据和对象的模块
• pickle_protocol – 指定pickle protocal 可以覆盖默认参数

torch.load[source]

torch.load(f, map_location=None, pickle_module=<module 'pickle' from '/home/jenkins/miniconda/lib/python3.5/pickle.py'>)

从磁盘文件中读取一个通过torch.save()保存的对象。 torch.load() 可通过参数map_location 动态地进行内存重映射，使其能从不动设备中读取文件。一般调用时，需两个参数: storage 和 location tag. 返回不同地址中的storage，或着返回None (此时地址可以通过默认方法进行解析). 如果这个参数是字典的话，意味着其是从文件的地址标记到当前系统的地址标记的映射。 默认情况下， location tags中 "cpu"对应host tensors，‘cuda:device_id’ (e.g. ‘cuda:2’) 对应cuda tensors。 用户可以通过register_package进行扩展，使用自己定义的标记和反序列化方法。

参数:

• f – 类文件对象 (返回文件描述符)或一个保存文件名的字符串
• map_location – 一个函数或字典规定如何remap存储位置
• pickle_module – 用于unpickling元数据和对象的模块 (必须匹配序列化文件时的pickle_module )

例子:

>>> torch.load('tensors.pt')
# Load all tensors onto the CPU
>>> torch.load('tensors.pt', map_location=lambda storage, loc: storage)
# Map tensors from GPU 1 to GPU 0
>>> torch.load('tensors.pt', map_location={'cuda:1':'cuda:0'})

并行化 Parallelism

torch.get_num_threads

torch.get_num_threads() → int

获得用于并行化CPU操作的OpenMP线程数

---

torch.set_num_threads

torch.set_num_threads(int)

设定用于并行化CPU操作的OpenMP线程数

数学操作Math operations

Pointwise Ops

torch.abs

torch.abs(input, out=None) → Tensor

计算输入张量的每个元素绝对值

例子：

>>> torch.abs(torch.FloatTensor([-1, -2, 3]))
FloatTensor([1, 2, 3])

torch.acos(input, out=None) → Tensor

torch.acos(input, out=None) → Tensor

返回一个新张量，包含输入张量每个元素的反余弦。 参数：

• input (Tensor) – 输入张量
• out (Tensor, optional) – 结果张量

例子：

>>> a = torch.randn(4)
>>> a

-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.acos(a)
 2.2608
 1.2956
 1.1075
    nan
[torch.FloatTensor of size 4]

torch.add()

torch.add(input, value, out=None)

如果输入input是FloatTensor or DoubleTensor类型，则value 必须为实数，否则须为整数。【译注：似乎并非如此，无关输入类型，value取整数、实数皆可。】

• input (Tensor) – 输入张量
• value (Number) – 添加到输入每个元素的数
• out (Tensor, optional) – 结果张量

>>> a = torch.randn(4)
>>> a

 0.4050
-1.2227
 1.8688
-0.4185
[torch.FloatTensor of size 4]

>>> torch.add(a, 20)

 20.4050
 18.7773
 21.8688
 19.5815
[torch.FloatTensor of size 4]

torch.add(input, value=1, other, out=None)

两个张量 input and other的尺寸不需要匹配，但元素总数必须一样。

注意 :当两个张量形状不匹配时，输入张量的形状会作为输出张量的尺寸。

如果other是FloatTensor or DoubleTensor类型，则value 必须为实数，否则须为整数。【译注：似乎并非如此，无关输入类型，value取整数、实数皆可。】

参数:

• input (Tensor) – 第一个输入张量
• value (Number) – 用于第二个张量的尺寸因子
• other (Tensor) – 第二个输入张量
• out (Tensor, optional) – 结果张量

例子：

>>> import torch
>>> a = torch.randn(4)
>>> a

-0.9310
 2.0330
 0.0852
-0.2941
[torch.FloatTensor of size 4]

>>> b = torch.randn(2, 2)
>>> b

 1.0663  0.2544
-0.1513  0.0749
[torch.FloatTensor of size 2x2]

>>> torch.add(a, 10, b)
 9.7322
 4.5770
-1.4279
 0.4552
[torch.FloatTensor of size 4]

torch.addcdiv

torch.addcdiv(tensor, value=1, tensor1, tensor2, out=None) → Tensor

用tensor2对tensor1逐元素相除，然后乘以标量值value 并加到tensor。

张量的形状不需要匹配，但元素数量必须一致。

如果输入是FloatTensor or DoubleTensor类型，则value 必须为实数，否则须为整数。

参数：

• tensor (Tensor) – 张量，对 tensor1 ./ tensor 进行相加
• value (Number, optional) – 标量，对 tensor1 ./ tensor2 进行相乘
• tensor1 (Tensor) – 张量，作为被除数(分子)
• tensor2 (Tensor) –张量，作为除数(分母)
• out (Tensor, optional) – 输出张量

例子：

>>> t = torch.randn(2, 3)
>>> t1 = torch.randn(1, 6)
>>> t2 = torch.randn(6, 1)
>>> torch.addcdiv(t, 0.1, t1, t2)

 0.0122 -0.0188 -0.2354
 0.7396 -1.5721  1.2878
[torch.FloatTensor of size 2x3]

torch.addcmul

torch.addcmul(tensor, value=1, tensor1, tensor2, out=None) → Tensor

用tensor2对tensor1逐元素相乘，并对结果乘以标量值value然后加到tensor。 张量的形状不需要匹配，但元素数量必须一致。 如果输入是FloatTensor or DoubleTensor类型，则value 必须为实数，否则须为整数。

参数：

• tensor (Tensor) – 张量，对tensor1 ./ tensor 进行相加
• value (Number, optional) – 标量，对 tensor1 . tensor2 进行相乘
• tensor1 (Tensor) – 张量，作为乘子1
• tensor2 (Tensor) –张量，作为乘子2
• out (Tensor, optional) – 输出张量

例子：

>>> t = torch.randn(2, 3)
>>> t1 = torch.randn(1, 6)
>>> t2 = torch.randn(6, 1)
>>> torch.addcmul(t, 0.1, t1, t2)

 0.0122 -0.0188 -0.2354
 0.7396 -1.5721  1.2878
[torch.FloatTensor of size 2x3]

torch.asin

torch.asin(input, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的反正弦函数

参数：

• tensor (Tensor) – 输入张量
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.asin(a)
-0.6900
 0.2752
 0.4633
    nan
[torch.FloatTensor of size 4]

torch.atan

torch.atan(input, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的反正切函数

参数：

• tensor (Tensor) – 输入张量
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.atan(a)
-0.5669
 0.2653
 0.4203
 0.9196
[torch.FloatTensor of size 4]

torch.atan2

torch.atan2(input1, input2, out=None) → Tensor

返回一个新张量，包含两个输入张量input1和input2的反正切函数

参数：

• input1 (Tensor) – 第一个输入张量
• input2 (Tensor) – 第二个输入张量
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.atan2(a, torch.randn(4))
-2.4167
 2.9755
 0.9363
 1.6613
[torch.FloatTensor of size 4]

torch.ceil

torch.ceil(input, out=None) → Tensor

天井函数，对输入input张量每个元素向上取整, 即取不小于每个元素的最小整数，并返回结果到输出。

参数：

• input (Tensor) – 输入张量
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> torch.ceil(a)

 2
 1
-0
-0
[torch.FloatTensor of size 4]

torch.clamp

torch.clamp(input, min, max, out=None) → Tensor

操作定义如下：

      | min, if x_i < min
y_i = | x_i, if min <= x_i <= max
      | max, if x_i > max

如果输入是FloatTensor or DoubleTensor类型，则参数min max 必须为实数，否则须为整数。【译注：似乎并非如此，无关输入类型，min， max取整数、实数皆可。】

参数：

• input (Tensor) – 输入张量
• min (Number) – 限制范围下限
• max (Number) – 限制范围上限
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> torch.clamp(a, min=-0.5, max=0.5)

 0.5000
 0.3912
-0.5000
-0.5000
[torch.FloatTensor of size 4]

torch.clamp(input, *, min, out=None) → Tensor

将输入input张量每个元素的限制到不小于min ，并返回结果到一个新张量。

如果输入是FloatTensor or DoubleTensor类型，则参数 min 必须为实数，否则须为整数。【译注：似乎并非如此，无关输入类型，min取整数、实数皆可。】

参数：

• input (Tensor) – 输入张量
• value (Number) – 限制范围下限
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> torch.clamp(a, min=0.5)

 1.3869
 0.5000
 0.5000
 0.5000
[torch.FloatTensor of size 4]

torch.clamp(input, *, max, out=None) → Tensor

将输入input张量每个元素的限制到不大于max ，并返回结果到一个新张量。

如果输入是FloatTensor or DoubleTensor类型，则参数 max 必须为实数，否则须为整数。【译注：似乎并非如此，无关输入类型，max取整数、实数皆可。】

参数：

• input (Tensor) – 输入张量
• value (Number) – 限制范围上限
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> torch.clamp(a, max=0.5)

 0.5000
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

torch.cos

torch.cos(input, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的余弦。

参数：

• input (Tensor) – 输入张量
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.cos(a)
 0.8041
 0.9633
 0.9018
 0.2557
[torch.FloatTensor of size 4]

torch.cosh

torch.cosh(input, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的双曲余弦。

参数：

• input (Tensor) – 输入张量
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.cosh(a)
 1.2095
 1.0372
 1.1015
 1.9917
[torch.FloatTensor of size 4]

torch.div()

torch.div(input, value, out=None)

如果输入是FloatTensor or DoubleTensor类型，则参数 value 必须为实数，否则须为整数。【译注：似乎并非如此，无关输入类型，value取整数、实数皆可。】

参数：

• input (Tensor) – 输入张量
• value (Number) – 除数
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(5)
>>> a

-0.6147
-1.1237
-0.1604
-0.6853
 0.1063
[torch.FloatTensor of size 5]

>>> torch.div(a, 0.5)

-1.2294
-2.2474
-0.3208
-1.3706
 0.2126
[torch.FloatTensor of size 5]

torch.div(input, other, out=None)

两张量形状不须匹配，但元素数须一致。

注意：当形状不匹配时，input的形状作为输出张量的形状。

参数：

• input (Tensor) – 张量(分子)
• other (Tensor) – 张量(分母)
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4,4)
>>> a

-0.1810  0.4017  0.2863 -0.1013
 0.6183  2.0696  0.9012 -1.5933
 0.5679  0.4743 -0.0117 -0.1266
-0.1213  0.9629  0.2682  1.5968
[torch.FloatTensor of size 4x4]

>>> b = torch.randn(8, 2)
>>> b

 0.8774  0.7650
 0.8866  1.4805
-0.6490  1.1172
 1.4259 -0.8146
 1.4633 -0.1228
 0.4643 -0.6029
 0.3492  1.5270
 1.6103 -0.6291
[torch.FloatTensor of size 8x2]

>>> torch.div(a, b)

-0.2062  0.5251  0.3229 -0.0684
-0.9528  1.8525  0.6320  1.9559
 0.3881 -3.8625 -0.0253  0.2099
-0.3473  0.6306  0.1666 -2.5381
[torch.FloatTensor of size 4x4]

torch.exp

torch.exp(tensor, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的指数。

参数：

• input (Tensor) – 输入张量
• out (Tensor, optional) – 输出张量

>>> torch.exp(torch.Tensor([0, math.log(2)]))
torch.FloatTensor([1, 2])

torch.floor

torch.floor(input, out=None) → Tensor

床函数: 返回一个新张量，包含输入input张量每个元素的floor，即不小于元素的最大整数。

参数：

• input (Tensor) – 输入张量
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> torch.floor(a)

 1
 0
-1
-1
[torch.FloatTensor of size 4]

torch.fmod

torch.fmod(input, divisor, out=None) → Tensor

计算除法余数。 除数与被除数可能同时含有整数和浮点数。此时，余数的正负与被除数相同。

参数： - input (Tensor) – 被除数 - divisor (Tensor or float) – 除数，一个数或与被除数相同类型的张量 - out (Tensor, optional) – 输出张量

例子：

>>> torch.fmod(torch.Tensor([-3, -2, -1, 1, 2, 3]), 2)
torch.FloatTensor([-1, -0, -1, 1, 0, 1])
>>> torch.fmod(torch.Tensor([1, 2, 3, 4, 5]), 1.5)
torch.FloatTensor([1.0, 0.5, 0.0, 1.0, 0.5])

参考: torch.remainder(), 计算逐元素余数， 相当于python 中的 % 操作符。

torch.frac

torch.frac(tensor, out=None) → Tensor

返回每个元素的分数部分。

例子：

>>> torch.frac(torch.Tensor([1, 2.5, -3.2])
torch.FloatTensor([0, 0.5, -0.2])

torch.lerp

torch.lerp(start, end, weight, out=None)

参数：

• start (Tensor) – 起始点张量
• end (Tensor) – 终止点张量
• weight (float) – 插值公式的weight
• out (Tensor, optional) – 结果张量

例子：

>>> start = torch.arange(1, 5)
>>> end = torch.Tensor(4).fill_(10)
>>> start

 1
 2
 3
 4
[torch.FloatTensor of size 4]

>>> end

 10
 10
 10
 10
[torch.FloatTensor of size 4]

>>> torch.lerp(start, end, 0.5)

 5.5000
 6.0000
 6.5000
 7.0000
[torch.FloatTensor of size 4]

torch.log

torch.log(input, out=None) → Tensor

计算input 的自然对数

参数：

• input (Tensor) – 输入张量
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(5)
>>> a

-0.4183
 0.3722
-0.3091
 0.4149
 0.5857
[torch.FloatTensor of size 5]

>>> torch.log(a)

    nan
-0.9883
    nan
-0.8797
-0.5349
[torch.FloatTensor of size 5]

torch.log1p

torch.log1p(input, out=None) → Tensor

注意：对值比较小的输入，此函数比torch.log()更准确。

如果输入是FloatTensor or DoubleTensor类型，则value 必须为实数，否则须为整数。

参数：

• input (Tensor) – 输入张量
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(5)
>>> a

-0.4183
 0.3722
-0.3091
 0.4149
 0.5857
[torch.FloatTensor of size 5]

>>> torch.log1p(a)

-0.5418
 0.3164
-0.3697
 0.3471
 0.4611
[torch.FloatTensor of size 5]

torch.mul

torch.mul(input, value, out=None)

如果输入是FloatTensor or DoubleTensor类型，则value 必须为实数，否则须为整数。【译注：似乎并非如此，无关输入类型，value取整数、实数皆可。】

参数：

• input (Tensor) – 输入张量
• value (Number) – 乘到每个元素的数
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(3)
>>> a

-0.9374
-0.5254
-0.6069
[torch.FloatTensor of size 3]

>>> torch.mul(a, 100)

-93.7411
-52.5374
-60.6908
[torch.FloatTensor of size 3]

torch.mul(input, other, out=None)

两计算张量形状不须匹配，但总元素数须一致。 注意：当形状不匹配时，input的形状作为输入张量的形状。

参数：

• input (Tensor) – 第一个相乘张量
• other (Tensor) – 第二个相乘张量
• out (Tensor, optional) – 结果张量

例子：

>>> a = torch.randn(4,4)
>>> a

-0.7280  0.0598 -1.4327 -0.5825
-0.1427 -0.0690  0.0821 -0.3270
-0.9241  0.5110  0.4070 -1.1188
-0.8308  0.7426 -0.6240 -1.1582
[torch.FloatTensor of size 4x4]

>>> b = torch.randn(2, 8)
>>> b

 0.0430 -1.0775  0.6015  1.1647 -0.6549  0.0308 -0.1670  1.0742
-1.2593  0.0292 -0.0849  0.4530  1.2404 -0.4659 -0.1840  0.5974
[torch.FloatTensor of size 2x8]

>>> torch.mul(a, b)

-0.0313 -0.0645 -0.8618 -0.6784
 0.0934 -0.0021 -0.0137 -0.3513
 1.1638  0.0149 -0.0346 -0.5068
-1.0304 -0.3460  0.1148 -0.6919
[torch.FloatTensor of size 4x4]

torch.neg

torch.neg(input, out=None) → Tensor

参数：

• input (Tensor) – 输入张量
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(5)
>>> a

-0.4430
 1.1690
-0.8836
-0.4565
 0.2968
[torch.FloatTensor of size 5]

>>> torch.neg(a)

 0.4430
-1.1690
 0.8836
 0.4565
-0.2968
[torch.FloatTensor of size 5]

torch.pow

torch.pow(input, exponent, out=None)

对输入input的按元素求exponent次幂值，并返回结果张量。 幂值exponent 可以为单一 float 数或者与input相同元素数的张量。

参数：

• input (Tensor) – 输入张量
• exponent (float or Tensor) – 幂值
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a

-0.5274
-0.8232
-2.1128
 1.7558
[torch.FloatTensor of size 4]

>>> torch.pow(a, 2)

 0.2781
 0.6776
 4.4640
 3.0829
[torch.FloatTensor of size 4]

>>> exp = torch.arange(1, 5)
>>> a = torch.arange(1, 5)
>>> a

 1
 2
 3
 4
[torch.FloatTensor of size 4]

>>> exp

 1
 2
 3
 4
[torch.FloatTensor of size 4]

>>> torch.pow(a, exp)

   1
   4
  27
 256
[torch.FloatTensor of size 4]

torch.pow(base, input, out=None)

base 为标量浮点值,input为张量， 返回的输出张量 out 与输入张量相同形状。

参数：

• base (float) – 标量值，指数的底
• input ( Tensor) – 幂值
• out (Tensor, optional) – 输出张量

例子：

>>> exp = torch.arange(1, 5)
>>> base = 2
>>> torch.pow(base, exp)

  2
  4
  8
 16
[torch.FloatTensor of size 4]

torch.reciprocal

torch.reciprocal(input, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的倒数，即 1.0/x。

参数：

• input (Tensor) – 输入张量
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> torch.reciprocal(a)

 0.7210
 2.5565
-1.1583
-1.8289
[torch.FloatTensor of size 4]

torch.remainder

torch.remainder(input, divisor, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的除法余数。 除数与被除数可能同时包含整数或浮点数。余数与除数有相同的符号。

参数：

• input (Tensor) – 被除数
• divisor (Tensor or float) – 除数，一个数或者与除数相同大小的张量
• out (Tensor, optional) – 输出张量

例子：

>>> torch.remainder(torch.Tensor([-3, -2, -1, 1, 2, 3]), 2)
torch.FloatTensor([1, 0, 1, 1, 0, 1])
>>> torch.remainder(torch.Tensor([1, 2, 3, 4, 5]), 1.5)
torch.FloatTensor([1.0, 0.5, 0.0, 1.0, 0.5])

参考: 函数torch.fmod() 同样可以计算除法余数，相当于 C 的 库函数fmod()

torch.round

torch.round(input, out=None) → Tensor

返回一个新张量，将输入input张量每个元素舍入到最近的整数。

参数：

• input (Tensor) – 输入张量
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a

 1.2290
 1.3409
-0.5662
-0.0899
[torch.FloatTensor of size 4]

>>> torch.round(a)

 1
 1
-1
-0
[torch.FloatTensor of size 4]

torch.rsqrt

torch.rsqrt(input, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的平方根倒数。

参数：

• input (Tensor) – 输入张量
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a

 1.2290
 1.3409
-0.5662
-0.0899
[torch.FloatTensor of size 4]

>>> torch.rsqrt(a)

 0.9020
 0.8636
    nan
    nan
[torch.FloatTensor of size 4]

torch.sigmoid

torch.sigmoid(input, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的sigmoid值。

参数：

• input (Tensor) – 输入张量
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a

-0.4972
 1.3512
 0.1056
-0.2650
[torch.FloatTensor of size 4]

>>> torch.sigmoid(a)

 0.3782
 0.7943
 0.5264
 0.4341
[torch.FloatTensor of size 4]

torch.sign

torch.sign(input, out=None) → Tensor

符号函数：返回一个新张量，包含输入input张量每个元素的正负。

参数：

• input (Tensor) – 输入张量
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.sign(a)

-1
 1
 1
 1
[torch.FloatTensor of size 4]

torch.sin

torch.sin(input, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的正弦。

参数：

• input (Tensor) – 输入张量
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.sin(a)
-0.5944
 0.2684
 0.4322
 0.9667
[torch.FloatTensor of size 4]

torch.sinh

torch.sinh(input, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的双曲正弦。

参数：

• input (Tensor) – 输入张量
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.sinh(a)
-0.6804
 0.2751
 0.4619
 1.7225
[torch.FloatTensor of size 4]

torch.sqrt

torch.sqrt(input, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的平方根。

参数：

• input (Tensor) – 输入张量
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a

 1.2290
 1.3409
-0.5662
-0.0899
[torch.FloatTensor of size 4]

>>> torch.sqrt(a)

 1.1086
 1.1580
    nan
    nan
[torch.FloatTensor of size 4]

torch.tan

torch.tan(input, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的正切。

参数：

• input (Tensor) – 输入张量
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.tan(a)
-0.7392
 0.2786
 0.4792
 3.7801
[torch.FloatTensor of size 4]

torch.tanh

torch.tanh(input, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的双曲正切。

参数：

• input (Tensor) – 输入张量
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.tanh(a)
-0.5625
 0.2653
 0.4193
 0.8648
[torch.FloatTensor of size 4]

torch.trunc

torch.trunc(input, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的截断值(标量x的截断值是最接近其的整数，其比x更接近零。简而言之，有符号数的小数部分被舍弃)。

参数：

• input (Tensor) – 输入张量
• out (Tensor, optional) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a

-0.4972
 1.3512
 0.1056
-0.2650
[torch.FloatTensor of size 4]

>>> torch.trunc(a)

-0
 1
 0
-0
[torch.FloatTensor of size 4]

python：机器学习模块PyTorch【下】