TechCodeview

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:
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:
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:
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:
12) tocha.nn.Sigmóide	Ele será usado para aplicar a função elemento a elemento como:
13) tocha.nn.Softplus	Ele será usado para aplicar a função elemento a elemento como:
14) tocha.nn.Softshrink	Ele será usado para aplicar a função de contração suave elemento a elemento como:
15) tocha.nn.Softsign	Ele será usado para aplicar a função elemento a elemento como:
16) tocha.nn.Tanh	Ele será usado para aplicar a função elemento a elemento como:
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:
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:
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:
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:
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.
2) tocha.nn.BatchNorm2d	É usado para aplicar normalização de lote em 4D.
3) tocha.nn.BatchNorm3d	É usado para aplicar normalização de lote em entradas 5D.
4) tocha.nn.GroupNorm	É usado para aplicar normalização de grupo em um minilote de entradas.
5) torch.nn.SyncBatchNorm	É usado para aplicar normalização de lote em entradas n-dimensionais.
6) tocha.nn.InstanceNorm1d	É usado para aplicar uma normalização de instância em uma entrada 3D.
7) tocha.nn.InstanceNorm2d	É utilizado para aplicar uma normalização de instância sobre uma entrada 4D.
8) tocha.nn.InstanceNorm3d	É usado para aplicar uma normalização de instância em uma entrada 5D.
9) tocha.nn.LayerNorm	É usado para aplicar normalização de camada em um minilote de entradas.
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:
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:
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: 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:
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 durante 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.
2) tocha.nn.PairwiseDistance	Ele calcula a distância entre pares em lote entre os vetores v1, v2 usando a norma p:
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:
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.
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:
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.
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).
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.
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.
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