PyTorch模块方法速查整理

﹏ヽ暗。殇╰゛Y 2023-02-17 11:19 1阅读 0赞

> Notes: PyTorch 常用的 modules 和 functions 快速查询

## 1. Tensor Operations [\[Docs\]][Docs] ##

torch
    ├── (Tensor)
    │   ├── view(*shape)      # e.g. x.view(-1, 3, 12) 
    │   │                     ##  -1 automatically filled
    │   └── item()            # get if Tensor is a scalar
    │
    ├── empty(*size)          # e.g. x = torch.empty(2, 3)
    ├── stack(tensors, dim=0)
    └── cat(tensors, dim=0)

## 2. Data Preparation [\[Docs\]][Docs 1] ##

torch
    └── utils
        └── data
            ├── Dataset     # A class to override 
            │               ##  `__len__` & `__getitem__`
            ├── TensorDataset(data_tensor, target_tensor)
            ├── DataLoader(dataset, batch_size=1,
            │              shuffle=False,
            │              collate_fn=\
            │                  <function default_collate>)
            │               # define `collate_fn` yourself
            └── sampler
                ├── SequentialSampler(data_source)
                └── RandomSampler(data_source)

## 3. NN (Neural Network) Model Construction [\[Docs\]][Docs 2] ##

神经网络部分为PyTorch 最主要模块，文档也最复杂，主要包括

*  [torch.nn][Docs 2]
 *  [torch.nn.functional][]
 *  [torch.nn.init][]
 *  [torch.optim][]
 *  [torch.autograd][]

### 3.1. Training ###

torch
    ├── (Tensor) #（Tensor）- torch.Tensor中的methods，下同
    │   ├── backward()
    │   │
    │   ├── cpu()
    │   ├── cuda()
    │   └── to(torch.device)            # x = x.to(device)
    ├── cuda
    │   └── is_available()
    │       #  if torch.cuda.is_available():
    │       ##     device = "cuda"
    │       ## else: device = "cpu"
    │
    ├── nn as nn  # import tensor.nn as nn
    │   │### Models ###
    │   ├── Module
    │   │   ├── load_state_dict(torch.load(PATH))
    │   │   ├── train()
    │   │   └── eval()
    │   ├── Sequential(layers)
    │   │
    │   │### Initializations ###
    │   ├── init
    │   │   └── uniform_(w)     # In-place, 
    │   │                       ##  w is a `torch.Tensor`.
    │   │
    │   │### Layers ###
    │   ├── Linear(in_feat, out_feat)
    │   ├── Dropout(rate)
    │   │
    │   │### Activations ###
    │   ├── Softmax(dim=None)
    │   ├── Sigmoid()
    │   ├── ReLU()
    │   ├── LeakyReLU(negative_slope=0.01)
    │   ├── Tanh()
    │   ├── GELU()
    │   ├── ReLU6() # Model Compression
    │   │ # --> Corresponding functions
    │   ├── functional as F  ────────────────────────────┐
    │   │   ├── softmax(input, dim=None)                 │
    │   │   ├── sigmoid(input)                           │
    │   │   ├── relu(input)                              │
    │   │   ├── leaky_relu(input,                        │
    │   │   │              negative_slope=0.01)          │
    │   │   ├── tanh(input)                              │
    │   │   ├── gelu(input)                              │
    │   │   └── relu6(input)                             │
    │   │                                                │
    │   │### Losses ###                                  │
    │   ├── MSELoss()                                    │
    │   ├── CrossEntropyLoss()                           │
    │   ├── BCELoss()                                    │
    │   ├── NLLLoss()                                    │
    │   │ # --> Corresponding functions                  │
    │   └──<functional as F> <───────────────────────────┘
    │       ├── mse_loss(input, target)
    │       ├── cross_entropy(input, 
    │       │                 target: torch.LongTensor)
    │       ├── binary_cross_entropy(input, target)
    │       ├── log_softmax(input)
    │       └── nll_loss(log_softmax_output, target)
    │           # F.nll_loss(F.log_softmax(input), target)
    │
    │    ### Optimizers ###
    ├── optim
    │   ├── (Optimizer)
    │   │       ├── zero_grad()
    │   │       ├── step()
    │   │       └── state_dict()
    │   │  
    │   ├── SGD(model.parameters(), lr=0.1, momentum=0.9)
    │   ├── Adagrad(model.parameters(), lr=0.01, 
    │   │           lr_decay=0, weight_decay=0, 
    │   │           initial_accumulator_value=0,eps=1e-10)
    │   ├── RMSProp(model.parameters(), lr=0.01, 
    │   │           alpha=0.99, eps=1e-08, weight_decay=0,
    │   │           momentum=0)
    │   ├── Adam(model.parameters(), lr=0.001, 
    │   │        betas=(0.9, 0.999), eps=1e-08,
    │   │        weight_decay=0)
    │   │   
    │   └── lr_scheduler
    │       └── ReduceLROnPlateau(optimizer)
    │
    │── load(PATH)
    │── save(model, PATH)
    │
    └── autograd
        └── backward(tensors)

### 3.2. Testing ###

torch
    ├── nn
    │   └── Module
    │       ├── load_state_dict(torch.load(PATH))
    │       └── eval()
    ├── optim
    │   └── (Optimizer)
    │       └── state_dict()
    └── no_grad()              # with torch.no_grad(): ...

## 4. CNN (Convolutional Neural Networks) ##

*  [Convolutional Layers][]
 *  [Pooling Layers][]
 *  [torchvision][]

torch
    ├── (Tensor)
    │   └── view(*shape)
    ├── nn
    │   │### Layers ###
    │   ├── Conv2d(in_channels, out_channels, 
    │   │          kernel_size, stride=1, padding=0)
    │   ├── ConvTranspose2d(in_channels, out_channels, 
    │   │          kernel_size, stride=1, padding=0, 
    │   │          output_padding=0)
    │   ├── MaxPool2d(kernel_size, stride=None, 
    │   │             padding=0, dilation=1)
    │   │             # stride default: kernel_size
    │   ├── BatchNorm2d(num_feat)
    │   └── BatchNorm1d(num_feat)
    ├── stack(tensors, dim=0)
    └── cat(tensors, dim=0)
    
    torchvision
    ├── models as models # Useful pretrained
    ├── transforms as transforms
    │   ├── Compose(transforms) # Wrapper
    │   ├── ToPILImage(mode=None)
    │   ├── RandomHorizontalFlip(p=0.5)
    │   ├── RandomRotation(degrees)
    │   ├── ToTensor()
    │   └── Resize(size)
    └── utils
        ├── make_grid(tensor, nrow=8, padding=2)
        └── save_image(tensor, filename, nrow=8,padding=2)

## 5. RNN (Recurrent Neural Networks) ##

*  [Recurrent Layers][]
 *  [Gensim Word2Vec][]

torch
    ├── nn
    │   ├── Embedding(num_embed, embed_dim)
    │   │   # embedding = nn.Embedding(
    │   │   ##               *(w2vmodel.wv.vectors.shape))
    │   ├── Parameter(params: torch.FloatTensor)
    │   │   # embedding.weight = nn.Parameter(
    │   │   ##  torch.FloatTensor(w2vmodel.wv.vectors))
    │   ├── LongTensor          # Feeding Indices of words
    │   │
    │   ├── LSTM(inp_size, hid_size, num_layers)
    │   │   # input: input, (h_0, c_0)
    │   └── GRU(inp_size, hid_size, num_layers)
    ├── stack(tensors, dim=0)
    └── cat(tensors, dim=0)
        
    gensim
    └── models
        └── word2Vec
            └── Word2Vec(sentences) # list or words/tokens

# PyTorch常用组件总览 #

torch
    ├── (Tensor)
    │   ├── view
    │   ├── item
    │   ├── cpu()
    │   ├── cuda()
    │   ├── to(torch.device)
    │   └── backward
    ├── nn
    │   ├── Module
    │   │   ├── load_state_dict
    │   │   ├── train
    │   │   └── eval
    │   ├── Sequential
    │   │ # Layers
    │   ├── Linear
    │   ├── Dropout
    │   │ ## CNN
    │   ├── Conv2d
    │   ├── ConvTranspose2d
    │   ├── MaxPool2d
    │   ├── BatchNorm2d
    │   ├── BatchNorm1d # GAN
    │   │ ## RNN
    │   ├── Embedding
    │   ├── LSTM
    │   ├── GRU
    │   │ # Loss functions
    │   ├── MSELoss
    │   ├── CrossEntropyLoss
    │   ├── BCELoss
    │   │ # Activations
    │   ├── Sigmoid
    │   ├── ReLU
    │   ├── Tanh
    │   ├── ReLU6 # Network Compression
    │   │ # Initializations
    │   ├── init
    │   │   └── uniform_
    │   │
    │   ├── functional as F
    │   │   ├── relu
    │   │   ├── leakyrelu
    │   │   ├── gelu
    │   │   └── nll_loss
    │   │
    │   └── Parameter
    ├── optim
    │   ├── SGD
    │   ├── RMSProp
    │   ├── Adagrad
    │   ├── Adam
    │   ├── AdamW
    │   ├── lr_scheduler
    │   └── (Optimizer)
    │       ├── zero_grad
    │       ├── state_dict
    │       └── step 
    ├── utils
    │   └── data
    │       ├── Dataset
    │       ├── TensorDataset
    │       ├── DataLoader
    │       ├── sampler
    │       ├── SequentialSampler
    │       └── RandomSampler
    ├── cuda
    │   └── is_available
    ├── autograd
    │   └── backward
    │   # tensor operation
    ├── no_grad
    ├── empty
    ├── stack
    ├── cat
    │   # model save
    ├── load
    └── save
        
    torchvision
    ├── transforms
    │   ├── Compose
    │   ├── ToPILImage
    │   ├── RandomHorizontalFlip
    │   ├── RandomRotation
    │   ├── ToTensor
    │   └── Resize
    ├── models
    └── utils
        ├── make_grid
        └── save_image

参考：李宏毅助教-陈建成-PyTorch cheat sheet

[Docs]: https://pytorch.org/docs/1.2.0/tensors.html
[Docs 1]: https://pytorch.org/docs/1.2.0/data.html
[Docs 2]: https://pytorch.org/docs/1.2.0/nn.html
[torch.nn.functional]: https://pytorch.org/docs/1.2.0/nn.functional.html
[torch.nn.init]: https://pytorch.org/docs/1.2.0/nn.init.html
[torch.optim]: https://pytorch.org/docs/1.2.0/optim.html
[torch.autograd]: https://pytorch.org/docs/1.2.0/autograd.html
[Convolutional Layers]: https://pytorch.org/docs/1.2.0/nn.html#conv2d
[Pooling Layers]: https://pytorch.org/docs/1.2.0/nn.html#maxpool2d
[torchvision]: https://pytorch.org/docs/stable/torchvision/index.html
[Recurrent Layers]: https://pytorch.org/docs/1.2.0/nn.html#recurrent-layers
[Gensim Word2Vec]: https://radimrehurek.com/gensim/models/word2vec.html