logo

TechCodeview

torch.nn em PyTorch

PyTorch fornece o módulo torch.nn para nos ajudar na criação e treinamento da rede neural. Primeiro treinaremos a rede neural básica no conjunto de dados MNIST sem usar nenhum recurso desses modelos. Usaremos apenas a funcionalidade básica do tensor PyTorch e, em seguida, adicionaremos gradativamente um recurso de torch.nn por vez.

torch.nn nos fornece muito mais classes e módulos para implementar e treinar a rede neural.

O pacote nn contém os seguintes módulos e classes:

Sim não Classe e Módulo Descrição
1. tocha.nn.Parâmetro É um tipo de tensor que deve ser considerado um parâmetro de módulo.
2. Containers
1) tocha.nn.Module É uma classe base para todos os módulos de rede neural.
2) tocha.nn.Sequencial É um contêiner sequencial no qual os Módulos serão adicionados na mesma ordem em que são passados ​​​​no construtor.
3) tocha.nn.ModuleList Isso conterá submódulos em uma lista.
4) tocha.nn.ModuleDict Isso manterá submódulos em um diretório.
5) torch.nn.ParameterList Isso manterá os parâmetros em uma lista.
6) tocha.nn.parameterDict Isso manterá os parâmetros em um diretório.
3. Camadas de convolução
1) tocha.nn.Conv1d Este pacote será usado para aplicar uma convolução 1D sobre um sinal de entrada composto por vários planos de entrada.
2) tocha.nn.Conv2d Este pacote será usado para aplicar uma convolução 2D sobre um sinal de entrada composto por vários planos de entrada.
3) tocha.nn.Conv3d Este pacote será usado para aplicar uma convolução 3D sobre um sinal de entrada composto por vários planos de entrada.
4) tocha.nn.ConvTranspose1d Este pacote será usado para aplicar um operador de convolução transposta 1D sobre uma imagem de entrada composta por vários planos de entrada.
5) tocha.nn.ConvTranspose2d Este pacote será usado para aplicar um operador de convolução transposta 2D sobre uma imagem de entrada composta por vários planos de entrada.
6) tocha.nn.ConvTranspose3d Este pacote será usado para aplicar um operador de convolução transposta 3D sobre uma imagem de entrada composta por vários planos de entrada.
7) tocha.nn.Unfold É usado para extrair blocos locais deslizantes de um tensor de entrada em lote.
8) tocha.nn.Fold É usado para combinar uma matriz de blocos locais deslizantes em um grande tensor contendo.
4. Agrupando camadas
1) tocha.nn.MaxPool1d É usado para aplicar um pooling 1D max sobre um sinal de entrada composto por vários planos de entrada.
2) tocha.nn.MaxPool2d É usado para aplicar um pooling máximo 2D sobre um sinal de entrada composto por vários planos de entrada.
3) tocha.nn.MaxPool3d É usado para aplicar um pooling 3D max sobre um sinal de entrada composto por vários planos de entrada.
4) tocha.nn.MaxUnpool1d É usado para calcular o inverso parcial de MaxPool1d.
5) tocha.nn.MaxUnpool2d É usado para calcular o inverso parcial de MaxPool2d.
6) tocha.nn.MaxUnpool3d É usado para calcular o inverso parcial de MaxPool3d.
7) tocha.nn.AvgPool1d É usado para aplicar um agrupamento médio 1D sobre um sinal de entrada composto por vários planos de entrada.
8) tocha.nn.AvgPool2d É usado para aplicar um agrupamento médio 2D sobre um sinal de entrada composto por vários planos de entrada.
9) tocha.nn.AvgPool3d É usado para aplicar um agrupamento médio 3D sobre um sinal de entrada composto por vários planos de entrada.
10) tocha.nn.FractionalMaxPool2d É usado para aplicar um agrupamento máximo fracionário 2D sobre um sinal de entrada composto por vários planos de entrada.
11) tocha.nn.LPPool1d É usado para aplicar um agrupamento de média de potência 1D sobre um sinal de entrada composto por vários planos de entrada.
12) tocha.nn.LPPool2d É usado para aplicar um agrupamento de média de potência 2D sobre um sinal de entrada composto por vários planos de entrada.
13) torch.nn.AdavtiveMaxPool1d É usado para aplicar um agrupamento máximo adaptativo 1D sobre um sinal de entrada composto por vários planos de entrada.
14) tocha.nn.AdavtiveMaxPool2d É usado para aplicar um agrupamento máximo adaptativo 2D sobre um sinal de entrada composto por vários planos de entrada.
15) torch.nn.AdavtiveMaxPool3d É usado para aplicar um pool máximo adaptativo 3D sobre um sinal de entrada composto por vários planos de entrada.
16) torch.nn.AdavtiveAvgPool1d É usado para aplicar um agrupamento médio adaptativo 1D sobre um sinal de entrada composto por vários planos de entrada.
17) tocha.nn.AdavtiveAvgPool2d É usado para aplicar um agrupamento médio adaptativo 2D sobre um sinal de entrada composto por vários planos de entrada.
18) tocha.nn.AdavtiveAvgPool3d É usado para aplicar um agrupamento médio adaptativo 3D sobre um sinal de entrada composto por vários planos de entrada.
5. Camadas de preenchimento
1) tocha.nn.ReflectionPad1d Ele preencherá o tensor de entrada usando a reflexão do limite de entrada.
2) tocha.nn.ReflactionPad2d Ele preencherá o tensor de entrada usando a reflexão do limite de entrada.
3) tocha.nn.ReplicationPad1 Ele preencherá o tensor de entrada usando a replicação do limite de entrada.
4) tocha.nn.ReplicationPad2d Ele preencherá o tensor de entrada usando a replicação do limite de entrada.
5) torch.nn.ReplicationPad3d Ele preencherá o tensor de entrada usando a replicação do limite de entrada.
6) tocha.nn.ZeroPad2d Ele preencherá os limites do tensor de entrada com zero.
7) tocha.nn.ConstantPad1d Ele preencherá os limites do tensor de entrada com um valor constante.
8) tocha.nn.ConstantPad2d Ele preencherá os limites do tensor de entrada com um valor constante.
9) tocha.nn.ConstantPad3d Ele preencherá os limites do tensor de entrada com um valor constante.
6. Ativações não lineares (soma ponderada, não linearidade)
1) tocha.nn.ELU Ele será usado para aplicar a função elemento a elemento:
ELU(x)=máx(0,x)+min(0,α*(exp(x)-1))
2) tocha.nn.Hardshrink Ele será usado para aplicar a função de forte contração, função elemento a elemento:
torch.nn em PyTorch
3) tocha.nn.LeakyReLU Ele será usado para aplicar a função elemento a elemento:
LeakyReLu(x)=max(0,x) +inclinação_negativa*min(0,x)
4) torch.nn.LogSigmoid Ele será usado para aplicar a função elemento a elemento:
torch.nn em PyTorch
5) torch.nn.MultiheadAttention É utilizado para permitir que o modelo atenda informações de diferentes subespaços de representação
6) tocha.nn.PReLU Será usado para aplicar a função elemento a elemento:
PReLU(x)=máx(0,x)+a*min(0,x)
7) tocha.nn.ReLU Ele será usado para aplicar a função de unidade linear retificada elemento a elemento:
ReLU(x)=máx(0,x)
8) tocha.nn.ReLU6 Será usado para aplicar a função elemento a elemento:
ReLU6(x)=min(máx(0,x),6)
9) tocha.nn.RReLU Ele usará para aplicar a função de unidade linear retificada com vazamento aleatório, elemento a elemento, conforme descrito no artigo:
torch.nn em PyTorch
10) tocha.nn.SELU Ele será usado para aplicar a função elemento a elemento como:
SELU(x)=escala*(max(0,x)+ min(0,a*(exp(x)-1)))

Aqui α= 1,6732632423543772848170429916717 e escala = 1,0507009873554804934193349852946.
11) tocha.nn.TARGET Ele será usado para aplicar a função elemento a elemento como:
torch.nn em PyTorch
12) tocha.nn.Sigmóide Ele será usado para aplicar a função elemento a elemento como:
torch.nn em PyTorch
13) tocha.nn.Softplus Ele será usado para aplicar a função elemento a elemento como:
torch.nn em PyTorch
14) tocha.nn.Softshrink Ele será usado para aplicar a função de contração suave elemento a elemento como:
torch.nn em PyTorch
15) tocha.nn.Softsign Ele será usado para aplicar a função elemento a elemento como:
torch.nn em PyTorch
16) tocha.nn.Tanh Ele será usado para aplicar a função elemento a elemento como:
torch.nn em PyTorch
17) tocha.nn.Tanhshrink Ele será usado para aplicar a função elemento a elemento como:
Tanhshrink(x)=x-Tanh(x)
18) tocha.nn.Threshold Ele usará os limites de cada elemento do Tensor de entrada. Limite é definido como:
torch.nn em PyTorch
7. Ativações não lineares (outras)
1) tocha.nn.Softmin É usado para aplicar a função softmin a um Tensor de entrada n-dimensional para redimensioná-los. Depois disso, os elementos do Tensor de saída n-dimensional estão no intervalo 0, 1 e somam 1. Softmin é definido como:
torch.nn em PyTorch
2) tocha.nn.Softmax É usado para aplicar a função softmax a um Tensor de entrada n-dimensional para redimensioná-los. Depois disso, os elementos do Tensor de saída n-dimensional estão no intervalo 0, 1 e somam 1. Softmax é definido como:
torch.nn em PyTorch
3) tocha.nn.Softmax2d É usado para aplicar SoftMax sobre recursos a cada localização espacial.
4) tocha.nn.LogSoftmax É usado para aplicar a função LogSoftmax a um Tensor de entrada n-dimensional. A função LofSoftmax pode ser definida como:
torch.nn em PyTorch
5) torch.nn.AdaptiveLogSoftmaxWithLoss É uma estratégia para treinar modelos com grandes espaços de saída. É muito eficaz quando a distribuição dos rótulos é altamente desequilibrada
8. Camadas de normalização
1) tocha.nn.BatchNorm1d É usado para aplicar normalização de lote em entradas 2D ou 3D.
torch.nn em PyTorch
2) tocha.nn.BatchNorm2d É usado para aplicar normalização de lote em 4D.
torch.nn em PyTorch
3) tocha.nn.BatchNorm3d É usado para aplicar normalização de lote em entradas 5D.
torch.nn em PyTorch
4) tocha.nn.GroupNorm É usado para aplicar normalização de grupo em um minilote de entradas.
torch.nn em PyTorch
5) torch.nn.SyncBatchNorm É usado para aplicar normalização de lote em entradas n-dimensionais.
torch.nn em PyTorch
6) tocha.nn.InstanceNorm1d É usado para aplicar uma normalização de instância em uma entrada 3D.
torch.nn em PyTorch
7) tocha.nn.InstanceNorm2d É utilizado para aplicar uma normalização de instância sobre uma entrada 4D.
torch.nn em PyTorch
8) tocha.nn.InstanceNorm3d É usado para aplicar uma normalização de instância em uma entrada 5D.
torch.nn em PyTorch
9) tocha.nn.LayerNorm É usado para aplicar normalização de camada em um minilote de entradas.
torch.nn em PyTorch
10) torch.nn.LocalResponseNorm É utilizado para aplicar a normalização da resposta local sobre um sinal de entrada composto por vários planos de entrada, onde o canal ocupa a segunda dimensão.
9. Camadas recorrentes
1) tocha.nn.RNN É usado para aplicar um Elman RNN multicamadas com não linearidade tanh ou ReLU a uma sequência de entrada. Cada camada calcula a seguinte função para cada elemento na sequência de entrada:
ht=tanh(Welesxt+beles+Wahtt-1+bah)
2) tocha.nn.LSTM Ele é usado para aplicar um RNN de memória de longo prazo multicamadas (LSTM) a uma sequência de entrada. Cada camada calcula a seguinte função para cada elemento na sequência de entrada:
torch.nn em PyTorch
3) tocha.nn.GRU Ele é usado para aplicar uma unidade recorrente controlada multicamada (GRU) RNN a uma sequência de entrada. Cada camada calcula a seguinte função para cada elemento na sequência de entrada:
torch.nn em PyTorch
4) tocha.nn.RNNCell É usado para aplicar uma célula Elman RNN com não linearidade tanh ou ReLU a uma sequência de entrada. Cada camada calcula a seguinte função para cada elemento na sequência de entrada:
h'=tanh(Welesx+beles+Wahh+bah)
ReLU é usado no lugar de tanh
5) tocha.nn.LSTMCell É usado para aplicar uma célula de memória de longo prazo (LSTM) a uma sequência de entrada. Cada camada calcula a seguinte função para cada elemento na sequência de entrada:
torch.nn em PyTorch
Onde σ é a função sigmóide e * é o produto de Hadamard.
6) tocha.nn.GRUCell É usado para aplicar uma célula de unidade recorrente controlada (GRU) a uma sequência de entrada. Cada camada calcula a seguinte função para cada elemento na sequência de entrada:
torch.nn em PyTorch
10. Camadas lineares
1) tocha.nn.Identidade É um operador de identidade de espaço reservado que não diferencia argumentos.
2) tocha.nn.Linear É usado para aplicar uma transformação linear aos dados recebidos:
y=xAT+b
3) tocha.nn.Bilinear É usado para aplicar uma transformação bilinear aos dados recebidos:
y=x1Machado2+b
onze. Camadas eliminadas
1) tocha.nn.Dropout É utilizado para regularização e prevenção da co-adaptação de neurônios. Um fator de torch.nn em PyTorchdurante o treinamento dimensiona a saída. Isso significa que o módulo calcula uma função de identidade durante a avaliação.
2) tocha.nn.Dropout2d Se os pixels adjacentes nos mapas de recursos estiverem correlacionados, torch.nn.Dropout não regularizará as ativações e diminuirá a taxa efetiva de aprendizado. Neste caso, torch.nn.Dropout2d() é usado para promover a independência entre mapas de recursos.
3) tocha.nn.Dropout3d Se os pixels adjacentes nos mapas de recursos estiverem correlacionados, torch.nn.Dropout não regularizará as ativações e diminuirá a taxa efetiva de aprendizado. Neste caso, torch.nn.Dropout2d() é usado para promover independência entre mapas de características.
4) torch.nn.AlphaDropout É usado para aplicar Alpha Dropout na entrada. Alpha Dropout é um tipo de Dropout que mantém a propriedade de autonormalização.
12. Camadas esparsas
1) torch.nn.Incorporação Ele é usado para armazenar incorporações de palavras e recuperá-las usando índices. A entrada do módulo é uma lista de índices e a saída é a incorporação de palavras correspondente.
2) torch.nn.EmbeddingBag É usado para calcular somas ou médias de 'sacos' de incorporação sem instanciar a incorporação intermediária.
13. Função Distância
1) torch.nn.CosineSimilarity Ele retornará a similaridade de cosseno entre x1 e x2, calculada ao longo de dim.
torch.nn em PyTorch
2) tocha.nn.PairwiseDistance Ele calcula a distância entre pares em lote entre os vetores v1, v2 usando a norma p:
torch.nn em PyTorch
14. Função de perda
1) tocha.nn.L1Perda É usado para um critério que mede o erro médio absoluto entre cada elemento na entrada x e no alvo y. A perda não reduzida pode ser descrita como:
eu(x,y)=eu={eu1,...,eun},eun=|xn-en|,
Onde N é o tamanho do lote.
2) torch.nn.MSELoss É usado para um critério que mede o erro quadrático médio entre cada elemento na entrada x e no alvo y. A perda não reduzida pode ser descrita como:
eu(x,y)=eu={eu1,...,eun},eun=(xn-en)2,
Onde N é o tamanho do lote.
3) torch.nn.CrossEntropyLoss Este critério combina nn.LogSoftmax() e nn.NLLLoss() em uma única classe. É útil quando treinamos um problema de classificação com classes C.
4) tocha.nn.CTCLoss A perda da Classificação Temporal Conexionista calcula a perda entre uma série temporal contínua e uma sequência alvo.
5) torch.nn.NLLLloss A perda de log-verossimilhança negativa é usada para treinar um problema de classificação com classes C.
6) torch.nn.PoissonNLLLloss A perda de log-verossimilhança negativa com a distribuição de Poisson de t
alvo~Poisson(entrada)perda(entrada,alvo)=alvo-entrada*log(alvo!)o alvo.
7) torch.nn.KLDivLoss É uma medida de distância útil para distribuição contínua e também quando realizamos regressão direta sobre o espaço de distribuição contínua de produção.
8) torch.nn.BCELoss É usado para criar um critério que mede a entropia cruzada binária entre o alvo e a saída. A perda não reduzida pode ser descrita como:
eu(x,y)=eu={eu1,...,eun},eun=-vn[en*logxn+ (1-anon)*log(1-xn)],
Onde N é o tamanho do lote.
9) torch.nn.BCEWithLogitsLoss Ele combina uma camada Sigmoid e BCELoss em uma única classe. Podemos aproveitar o truque log-sum-exp para estabilidade numérica combinando a operação em uma camada.
10) torch.nn.MarginRankingLoss Ele cria um critério que mede a perda de determinadas entradas x1, x2, dois tensores de minilote 1D e um tensor de minilote 1D de rótulo y que contém 1 ou -1. A função de perda para cada amostra no minilote é a seguinte:
perda(x,y)=max(0,-y*(x1-x2)+margem
11) torch.nn.HingeEmbeddingLoss HingeEmbeddingLoss mede a perda de um tensor de entrada x e um tensor de rótulos y que contém 1 ou -1. É usado para medir se duas entradas são semelhantes ou diferentes. A função de perda é definida como:
torch.nn em PyTorch
12) torch.nn.MultiLabelMarginLoss É usado para criar um critério que otimiza uma perda de dobradiça multiclasse e multiclassificação entre a entrada x e a saída y.
torch.nn em PyTorch
13) tocha.nn.SmoothL1Loss É usado para criar um critério que usa um termo quadrático se o erro absoluto por elemento cair abaixo de 1 e um termo L1 caso contrário. Também é conhecido como perda de Huber:
torch.nn em PyTorch
14) torch.nn.SoftMarginLoss É usado para criar um critério que otimiza a perda logística de classificação de duas classes entre o tensor de entrada x e o tensor alvo y que contém 1 ou -1.
torch.nn em PyTorch
15) torch.nn.MultiLabelSoftMarginLoss É usado para criar um critério que otimiza a perda multi-rótulo um contra todos com base na entropia máxima entre a entrada x e o alvo y de tamanho (N, C).
torch.nn em PyTorch
16) torch.nn.CosineEmbeddingLoss É usado para criar um critério que mede a perda de determinados tensores de entrada x1, x2 e um rótulo de tensor y com valores 1 ou -1. É usado para medir se duas entradas são semelhantes ou diferentes, usando a distância do cosseno.
torch.nn em PyTorch
17) torch.nn.MultiMarginLoss É usado para criar um critério que otimiza uma perda de dobradiça de classificação multiclasse entre a entrada x e a saída y.
torch.nn em PyTorch
18) torch.nn.TripletMarginLoss É usado para criar um critério que mede a perda tripla de determinados tensores de entrada x1, x2, x3 e uma margem com valor maior que 0. É usado para medir uma semelhança relativa entre amostras. Um trio é composto por uma âncora, um exemplo positivo e um exemplo negativo.
L(uma,p,n)=máx{d(umaeu,peu)-d(umaeu,neu)+margem,0}
quinze. Camadas de visão
1) tocha.nn.PixelShuffle É usado para reorganizar os elementos em um tensor de forma(*,C×r2,H,W) para um tensor de forma (*,C,H×r,W,r)
2) tocha.nn.Upsample É usado para aumentar a amostragem de dados 1D, 2D ou 3D multicanal.
3) torch.nn.upsamplingNearest2d É usado para aplicar upsampling 2D do vizinho mais próximo a um sinal de entrada composto por vários canais de entrada.
4) torch.nn.UpsamplingBilinear2d É usado para aplicar upsampling bilinear 2D a um sinal de entrada composto por múltiplos canais de entrada.
16. Camadas DataParallel (multi-GPU, distribuídas)
1) tocha.nn.DataParallel É usado para implementar o paralelismo de dados no nível do módulo.
2) torch.nn.DistributedDataParallel Ele é usado para implementar o paralelismo de dados distribuídos, baseado no pacote torch.distributed no nível do módulo.
3) torch.nn.DistributedDataParallelCPU É usado para implementar paralelismo de dados distribuídos para a CPU no nível do módulo.
17. Serviços de utilidade pública
1) tocha.nn.clip_grad_norm_ É usado para cortar a norma de gradiente de um iterável de parâmetros.
2) tocha.nn.clip_grad_value_ É usado para cortar a norma de gradiente de um iterável de parâmetros no valor especificado.
3) torch.nn.parameters_to_vector É usado para converter parâmetros em um vetor.
4) tocha.nn.vector_to_parameters É usado para converter um vetor em parâmetros.
5) tocha.nn.weight_norm É usado para aplicar a normalização de peso a um parâmetro em um determinado módulo.
6) tocha.nn.remove_weight_norm É usado para remover a normalização e reparametrização de peso de um módulo.
7) tocha.nn.spectral_norm É usado para aplicar normalização espectral a um parâmetro em um determinado módulo.
8) torch.nn.PackedSequence Ele será usado para armazenar os dados e a lista de batch_sizes de uma sequência compactada.
9) torch.nn.pack_padded_sequence É usado para empacotar um Tensor contendo sequências preenchidas de comprimento variável.
10) torch.nn.pad_packed_sequence É usado para preencher um lote compactado de sequências de comprimento variável.
11) tocha.nn.pad_sequence É usado para preencher uma lista de tensores de comprimento variável com valor de preenchimento.
12) torch.nn.pack_sequence É usado para empacotar uma lista de tensores de comprimento variável
13) torch.nn.remove_spectral_norm É usado para remover a normalização espectral e a parametrização de um módulo.

Referência:

https://pytorch.org/docs/stable/nn.html