pytorch

pytorch

torch.Tensor - PyTorch中文文档 (pytorch-cn.readthedocs.io)

创建张量

torch.eye(n, m=None, out=None)
torch.ones(*sizes, out=None) → Tensor
torch.zeros(*sizes, out=None) → Tensor
torch.rand(*sizes, out=None) → Tensor
torch.linspace(start, end, steps=100, out=None) → Tensor
torch.range(start, end, step=1, out=None) → Tensor
####从numpy转，适合图片
torch.from_numpy(ndarray) → Tensor

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

#在给定维度上对输入的张量序列seq 进行连接操作。
torch.cat(inputs, dimension=0) → Tensor
例：torch.cat((x, x, x), 0)

#在给定维度(轴)上将输入张量进行分块儿。
torch.chunk(tensor, chunks, dim=0)

#沿着指定维度对输入进行切片
torch.index_select(input, dim, index, out=None) → Tensor

##将输入张量分割成相等形状的chunks（如果可分）。 如果沿指定维的张量形状大小不能被split_size 整分， 则最后一个分块会小于其它分块。
torch.split(tensor, split_size, dim=0)

#将输入张量形状中的1 去除并返回。当给定dim时，那么挤压操作只在给定维度上。
#注意： 返回张量与输入张量共享内存，所以改变其中一个的内容会改变另一个。
torch.squeeze(input, dim=None, out=None)

#返回一个新的张量，对输入的制定位置插入维度 1
torch.unsqueeze(input, dim, out=None)

#沿着一个新维度对输入张量序列进行连接。 序列中所有的张量都应该为相同形状。
torch.stack(sequence, dim=0)

#返回输入矩阵input的转置。交换维度dim0和dim1。
torch.transpose(input, dim0, dim1, out=None) → Tensor

随机抽样

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

#返回一个张量，每行包含从input相应行中定义的多项分布中抽取的num_samples个样本。
torch.multinomial(input, num_samples,replacement=False, out=None) → LongTensor

torch.normal()

序列化 Serialization

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

数学操作

#计算输入张量的每个元素绝对值
torch.abs(input, out=None) → Tensor

#对输入张量input逐元素加上标量值value，并返回结果到一个新的张量out
torch.add()

#用tensor2对tensor1逐元素相乘，并对结果乘以标量值value然后加到tensor
torch.addcmul(tensor, value=1, tensor1, tensor2, out=None) → Tensor

#用标量值value乘以输入input的每个元素，并返回一个新的结果张量。
torch.mul(input, value, out=None)

#返回一个新张量，包含输入input张量每个元素的sigmoid值。
torch.sigmoid(input, out=None) → Tensor

torch.mean(input) → float

比较操作

#比较元素相等性。第二个参数可为一个数或与第一个参数同类型形状的张量。
torch.eq(input, other, out=None) → Tensor

#如果两个张量有相同的形状和元素值，则返回True ，否则 False。
torch.equal(tensor1, tensor2) → bool

#返回输入张量给定维度上每行的最大值，并同时返回每个最大值的位置索引。
torch.max(input, dim, max=None, max_indices=None) -> (Tensor, LongTensor)

torch.sort(input, dim=None, descending=False, out=None) -> (Tensor, LongTensor)

#沿给定dim维度返回输入张量input中 k 个最大值。 如果不指定dim，则默认为input的最后一维。 如果为largest为 False ，则返回最小的 k 个值。
torch.topk(input, k, dim=None, largest=True, sorted=True, out=None) -> (Tensor, LongTensor)

其它操作

#返回沿着维度dim上，两个张量input和other的向量积（叉积）。 input和other 必须有相同的形状，且指定的dim维上size必须为3。
torch.cross(input, other, dim=-1, out=**None**) → Tensor

#torch.addbmm(beta=1, mat, alpha=1, batch1, batch2, out=None) → Tensor
torch.addbmm(beta=1, mat, alpha=1, batch1, batch2, out=None) → Tensor

#对矩阵mat1和mat2进行矩阵乘操作。矩阵mat加到最终结果。
torch.addmm(beta=1, mat, alpha=1, mat1, mat2, out=None) → Tensor’

#对存储在两个批batch1和batch2内的矩阵进行批矩阵乘操作
torch.bmm(batch1, batch2, out=None) → Tensor

#对矩阵mat1和mat2进行相乘
torch.mm(mat1, mat2, out=None) → Tensor

#计算两个张量的点乘(内乘),两个张量都为1-D 向量.
torch.dot(tensor1, tensor2) → float

torch.Tensor

Torch定义了七种CPU tensor类型和八种GPU tensor类型：

torch.Tensor是默认的tensor类型（torch.FlaotTensor）的简称。

类型转换

byte()、char()、clone()、cpu()、double()、float()、int()、long()、short()

size()、tolist()

torch.nn

class torch.nn.Parameter()

Variable的一种，常被用于模块参数(module parameter)。

Parameters 是 Variable 的子类。Paramenters和Modules一起使用的时候会有一些特殊的属性，即：当Paramenters赋值给Module的属性的时候，他会自动的被加到 Module的 参数列表中(即：会出现在 parameters() 迭代器中)。将Varibale赋值给Module属性则不会有这样的影响。 这样做的原因是：我们有时候会需要缓存一些临时的状态(state), 比如：模型中RNN的最后一个隐状态。如果没有Parameter这个类的话，那么这些临时变量也会注册成为模型变量。

Variable 与 Parameter的另一个不同之处在于，Parameter不能被 volatile(即：无法设置volatile=True)而且默认requires_grad=True。Variable默认requires_grad=False。

class torch.nn.Module

所有网络的基类。

你的模型也应该继承这个类。

Modules也可以包含其它Modules,允许使用树结构嵌入他们。你可以将子模块赋值给模型属性。

.cuda(device_id=None)

.eval()/.train(mode=True)

仅仅当模型中有Dropout和BatchNorm是才会有影响。

.zero_grad()

将module中的所有模型参数的梯度设置为0.

torch.nn.Sequential(* args)

一个时序容器。Modules 会以他们传入的顺序被添加到容器中。

model = nn.Sequential(
          nn.Conv2d(1,20,5),
          nn.ReLU(),
          nn.Conv2d(20,64,5),
          nn.ReLU()
        )

torch.nn.ModuleList(modules=None)

ModuleList可以像一般的Python list一样被索引。而且ModuleList中包含的modules已经被正确的注册，对所有的module method可见。

class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.linears = nn.ModuleList([nn.Linear(10, 10) for i in range(10)])

    def forward(self, x):
        # ModuleList can act as an iterable, or be indexed         using ints
        for i, l in enumerate(self.linears):
            x = self.linears[i // 2](x) + l(x)
        return x

.append(module)

.extend(modules)

卷积层

torch.nn.Conv1d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)
torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

池化层

torch.nn.MaxPool1d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)

Normalization layers

torch.nn.BatchNorm1d(num_features, eps=1e-05, momentum=0.1, affine=True)
torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True)

torch.nn.RNN( args, * kwargs)

torch.nn.LSTM( args, * kwargs)

参数说明:

• input_size – 输入的特征维度
• hidden_size – 隐状态的特征维度
• num_layers – 层数（和时序展开要区分开）
• bias – 如果为False，那么LSTM将不会使用\(b_{ih},b_{hh}\)，默认为True。
• batch_first – 如果为True，那么输入和输出Tensor的形状为(batch, seq, feature)
• dropout – 如果非零的话，将会在RNN的输出上加个dropout，最后一层除外。
• bidirectional – 如果为True，将会变成一个双向RNN，默认为False。

Linear layers

torch.nn.Linear(in_features, out_features, bias=True)

Dropout layers

torch.nn.Dropout(p=0.5, inplace=False)

Sparse layers

torch.nn.Embedding(num_embeddings, embedding_dim, padding_idx=None, max_norm=None, norm_type=2, scale_grad_by_freq=False, sparse=False)

torch.nn.UpsamplingNearest2d(size=None, scale_factor=None)

上采样

Loss functions

class torch.nn.L1Loss(size_average=True)
class torch.nn.MSELoss(size_average=True)
class torch.nn.CrossEntropyLoss(weight=None, size_average=True)

torch.nn.functional

torch.nn的类会在forward()方法中调用torch.nn.functional的函数，所以可以理解为nn模块中的方法是对nn.functional模块中方法的更高层的封装。

torch.autograd

torch.autograd提供了类和函数用来对任意标量函数进行求导。要想使用自动求导，只需要对已有的代码进行微小的改变。只需要将所有的tensor包含进Variable对象中即可。

torch.optim

optimizer = optim.SGD(model.parameters(), lr = 0.01, momentum=0.9)
optimizer = optim.Adam([var1, var2], lr = 0.0001)

所有的optimizer都实现了step()方法，这个方法会更新所有的参数。它能按两种方式来使用：

optimizer.step()

这是大多数optimizer所支持的简化版本。一旦梯度被如backward()之类的函数计算好后，我们就可以调用这个函数。

for input, target in dataset:
    optimizer.zero_grad()
    output = model(input)
    loss = loss_fn(output, target)
    loss.backward()
    optimizer.step()

torch.multiprocessing

封装了multiprocessing模块。用于在相同数据的不同进程中共享视图。

一旦张量或者存储被移动到共享单元(见share_memory_()),它可以不需要任何其他复制操作的发送到其他的进程中。

这个API与原始模型完全兼容，为了让张量通过队列或者其他机制共享，移动到内存中，我们可以

由原来的import multiprocessing改为import torch.multiprocessing。

由于API的相似性，我们没有记录这个软件包的大部分内容，我们建议您参考原始模块的非常好的文档。

torch.utils.data

class torch.utils.data.Dataset

继承Dataset，重写__getitem__ len

class torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=False, sampler=None, num_workers=0, collate_fn=, pin_memory=False, drop_last=False)

torchvision

torchvision.datasets

torchvision.datasets中包含了以下数据集

• MNIST
• COCO（用于图像标注和目标检测）(Captioning and Detection)
• LSUN Classification
• ImageFolder
• Imagenet-12
• CIFAR10 and CIFAR100
• STL10

Datasets 拥有以下API:

__getitem__` `__len__

由于以上Datasets都是 torch.utils.data.Dataset的子类，所以，他们也可以通过torch.utils.data.DataLoader使用多线程（python的多进程）。

torchvision.models

torchvision.models模块的 子模块中包含以下模型结构。

• AlexNet
• VGG
• ResNet
• SqueezeNet
• DenseNet

import torchvision.models as models
#pretrained=True就可以使用预训练的模型
resnet18 = models.resnet18(pretrained=True)
alexnet = models.alexnet(pretrained=True)

torchvision.transform

#将多个transform组合起来使用。
class torchvision.transforms.Compose(transforms)

# 给定均值：(R,G,B) 方差：（R，G，B），将会把Tensor正则化。即：Normalized_image=(image-mean)/std。
torchvision.transforms.Normalize(mean, std)

实际应用

Tensor、numpy互转

Tensor转numpy

a.numpy()

numpy转Tensor

torch.from_numpy(a)

tensor类型转换

ts.int()

ts.cpu()

ts.cuda()

ts.numpy()

numpy数据转换

data.astype("int")

Avadataset 构建

class AvaDataset(Dataset):
    def __init__(self,opt):
        self.all_image_paths = sorted([opt.source+image_path for image_path in os.listdir(opt.source)])
        self.fps = 30
        self.stride = 32
        self.cap = None
        self.opt = opt
        print((len(self.all_image_paths)/self.fps)-2)
    def __getitem__(self, index):
        img0s = np.zeros((90,360,486,3))
        imgs = np.zeros((90,3,480,640))
        for i in range(90):###self.fps*index,self.fps*(index+3)
            img0 = cv2.imread(self.all_image_paths[i+self.fps*index])
            img0s[i] = img0 
            img = letterbox(img0, self.opt.img_size, stride=self.stride)[0]
            # Convert
            img = img[:, :, ::-1].transpose(2, 0, 1)  # BGR to RGB, to 3x416x416
            img = np.ascontiguousarray(img)
            imgs[i] = img
        return index,self.all_image_paths[self.fps*index], imgs, img0s, self.cap
    def __len__(self):
        return int(len(self.all_image_paths)/self.fps)-2

用for循环取出来

nn.X与F.X

nn.ReLU作为一个层结构，必须添加到nn.Module容器中才能使用，而F.ReLU则作为一个函数调用，看上去作为一个函数调用更方便更简洁。具体使用哪种方式，取决于编程风格。在PyTorch中,nn.X都有对应的函数版本F.X，但是并不是所有的F.X均可以用于forward或其它代码段中，因为当网络模型训练完毕时，在存储model时，在forward中的F.X函数中的参数是无法保存的。也就是说，在forward中，使用的F.X函数一般均没有状态参数，比如F.ReLU，F.avg_pool2d等，均没有参数，它们可以用在任何代码片段中。