PyTorch oferă modulul torch.nn pentru a ne ajuta în crearea și formarea rețelei neuronale. Vom antrena mai întâi rețeaua neuronală de bază pe setul de date MNIST fără a folosi nicio caracteristică din aceste modele. Vom folosi doar funcționalitatea de bază a tensorului PyTorch și apoi vom adăuga progresiv câte o caracteristică din torch.nn.

torch.nn ne oferă mai multe clase și module pentru a implementa și antrena rețeaua neuronală.

Pachetul nn conține următoarele module și clase:

Da nu	Clasa si Modul	Descriere
1.	torță.nn.Parametru	Este un tip de tensor care trebuie considerat ca un parametru de modul.
2.	Containere
1) lanternă.nn.Modul	Este o clasă de bază pentru toate modulele de rețea neuronală.
2) torţă.nn.Secvenţial	Este un container secvenţial în care modulele vor fi adăugate în aceeaşi ordine în care sunt trecute în constructor.
3) torță.nn.ModuleList	Aceasta va deține sub-module într-o listă.
4) torță.nn.ModuleDict	Aceasta va deține sub-module într-un director.
5) torță.nn.ParameterList	Aceasta va păstra parametrii într-o listă.
6) torță.nn.parameterDict	Acesta va păstra parametrii într-un director.
3.	Straturi de convoluție
1) torță.nn.Conv1d	Acest pachet va fi folosit pentru a aplica o convoluție 1D peste un semnal de intrare compus din mai multe planuri de intrare.
2) torță.nn.Conv2d	Acest pachet va fi folosit pentru a aplica o convoluție 2D peste un semnal de intrare compus din mai multe planuri de intrare.
3) torță.nn.Conv3d	Acest pachet va fi folosit pentru a aplica o convoluție 3D peste un semnal de intrare compus din mai multe planuri de intrare.
4) torță.nn.ConvTranspose1d	Acest pachet va fi folosit pentru a aplica un operator de convoluție transpus 1D peste o imagine de intrare compusă din mai multe planuri de intrare.
5) torță.nn.ConvTranspose2d	Acest pachet va fi folosit pentru a aplica un operator de convoluție transpus 2D peste o imagine de intrare compusă din mai multe planuri de intrare.
6) torță.nn.ConvTranspose3d	Acest pachet va fi folosit pentru a aplica un operator de convoluție transpus 3D peste o imagine de intrare compusă din mai multe planuri de intrare.
7) torță.nn.Desfășurare	Este folosit pentru a extrage blocuri locale glisante dintr-un tensor de intrare în lot.
8) torță.nn.Îndoiți	Este folosit pentru a combina o serie de blocuri locale glisante într-un tensor mare care conține.
4.	Straturi de grupare
1) torță.nn.MaxPool1d	Este folosit pentru a aplica un pooling 1D max peste un semnal de intrare compus din mai multe planuri de intrare.
2) torță.nn.MaxPool2d	Este folosit pentru a aplica un pooling 2D max peste un semnal de intrare compus din mai multe planuri de intrare.
3) torță.nn.MaxPool3d	Este folosit pentru a aplica un pooling 3D max peste un semnal de intrare compus din mai multe planuri de intrare.
4) torță.nn.MaxUnpool1d	Este folosit pentru a calcula inversul parțial al MaxPool1d.
5) torță.nn.MaxUnpool2d	Este folosit pentru a calcula inversul parțial al MaxPool2d.
6) torță.nn.MaxUnpool3d	Este folosit pentru a calcula inversul parțial al MaxPool3d.
7) torță.nn.AvgPool1d	Este folosit pentru a aplica un pooling mediu 1D peste un semnal de intrare compus din mai multe planuri de intrare.
8) torță.nn.AvgPool2d	Este folosit pentru a aplica un pooling mediu 2D peste un semnal de intrare compus din mai multe planuri de intrare.
9) torță.nn.AvgPool3d	Este folosit pentru a aplica un pooling mediu 3D peste un semnal de intrare compus din mai multe planuri de intrare.
10) torță.nn.FractionalMaxPool2d	Este folosit pentru a aplica un pooling maxim fracțional 2D peste un semnal de intrare compus din mai multe planuri de intrare.
11) torță.nn.LPPool1d	Este folosit pentru a aplica un pooling de putere medie 1D peste un semnal de intrare compus din mai multe planuri de intrare.
12) torță.nn.LPPool2d	Este folosit pentru a aplica un pooling 2D de putere medie peste un semnal de intrare compus din mai multe planuri de intrare.
13) torță.nn.AdavtiveMaxPool1d	Este folosit pentru a aplica un pooling max adaptiv 1D peste un semnal de intrare compus din mai multe planuri de intrare.
14) torță.nn.AdavtiveMaxPool2d	Este folosit pentru a aplica un pooling max adaptiv 2D peste un semnal de intrare compus din mai multe planuri de intrare.
15) torță.nn.AdavtiveMaxPool3d	Este folosit pentru a aplica un pooling max adaptiv 3D peste un semnal de intrare compus din mai multe planuri de intrare.
16) torță.nn.AdavtiveAvgPool1d	Este folosit pentru a aplica un pooling mediu adaptiv 1D peste un semnal de intrare compus din mai multe planuri de intrare.
17) torță.nn.AdavtiveAvgPool2d	Este folosit pentru a aplica un pooling mediu adaptiv 2D peste un semnal de intrare compus din mai multe planuri de intrare.
18) torță.nn.AdavtiveAvgPool3d	Este folosit pentru a aplica un pooling mediu adaptiv 3D peste un semnal de intrare compus din mai multe planuri de intrare.
5.	Straturi de umplutură
1) torță.nn.ReflectionPad1d	Acesta va acoperi tensorul de intrare folosind reflectarea limitei de intrare.
2) torță.nn.ReflactionPad2d	Acesta va acoperi tensorul de intrare folosind reflectarea limitei de intrare.
3) torță.nn.ReplicationPad1	Acesta va acoperi tensorul de intrare folosind replicarea graniței de intrare.
4) torță.nn.ReplicationPad2d	Acesta va acoperi tensorul de intrare folosind replicarea graniței de intrare.
5) torță.nn.ReplicationPad3d	Acesta va acoperi tensorul de intrare folosind replicarea graniței de intrare.
6) torță.nn.ZeroPad2d	Acesta va umple limitele tensorilor de intrare cu zero.
7) torță.nn.ConstantPad1d	Acesta va umple limitele tensorilor de intrare cu o valoare constantă.
8) torță.nn.ConstantPad2d	Acesta va umple limitele tensorilor de intrare cu o valoare constantă.
9) torță.nn.ConstantPad3d	Acesta va umple limitele tensorilor de intrare cu o valoare constantă.
6.	Activari neliniare (suma ponderata, neliniaritate)
1) torță.nn.ELU	Se va folosi pentru a aplica funcția element-wise: ELU(x)=max(0,x)+min(0,α*(exp(x)-1))
2) torță.nn.Hardshrink	Se va folosi pentru a aplica funcția de contracție dură, funcție de elemente:
3) torță.nn.LeakyReLU	Se va folosi pentru a aplica funcția element-wise: LeakyReLu(x)=max(0,x) +pantă_negativă*min(0,x)
4) torță.nn.LogSigmoid	Se va folosi pentru a aplica funcția element-wise:
5) torță.nn.MultiheadAtenție	Este folosit pentru a permite modelului să se ocupe de informații din diferite subspații de reprezentare
6) torță.nn.PReLU	Va fi folosit pentru a aplica funcția element-wise: PReLU(x)=max(0,x)+a*min(0,x)
7) torță.nn.ReLU	Se va folosi pentru a aplica funcția de unitate liniară rectificată în funcție de elemente: ReLU(x)=max(0,x)
8) torţă.nn.ReLU6	Va fi folosit pentru a aplica funcția element-wise: ReLU6(x)=min(max(0,x),6)
9) torță.nn.RReLU	Se va folosi pentru a aplica funcția de unitate liniară rectificată cu scurgere aleatorie, în funcție de elemente, așa cum este descris în lucrare:
10) torță.nn.SELU	Se va folosi pentru a aplica funcția element-wise ca: SELU(x)=scale*(max(0,x)+ min(0,a*(exp(x)-1))) Aici α= 1,6732632423543772848170429916717 și scară = 1,0507009873554804934193349852946.
11) torță.nn.TARGET	Se va folosi pentru a aplica funcția element-wise ca:
12) torță.nn.Sigmoid	Se va folosi pentru a aplica funcția element-wise ca:
13) lanterna.nn.Softplus	Se va folosi pentru a aplica funcția element-wise ca:
14) torță.nn.Contractare moale	Se va folosi pentru a aplica funcția de contracție moale în funcție de elemente ca:
15) torță.nn.Softsign	Se va folosi pentru a aplica funcția element-wise ca:
16) torță.nn.Tanh	Se va folosi pentru a aplica funcția element-wise ca:
17) torță.nn.Tanhshrink	Se va folosi pentru a aplica funcția element-wise ca: Tanhshrink(x)=x-Tanh(x)
18) torţă.nn.Prag	Va folosi pentru a pragește fiecare element al Tensorului de intrare. Pragul este definit ca:
7.	Activari neliniare (altele)
1) torță.nn.Softmin	Este folosit pentru a aplica funcția softmin unui Tensor de intrare n-dimensional pentru a le redimensiona. După aceea, elementele Tensorului de ieșire n-dimensională se află în intervalul 0, 1 și suma la 1. Softmin este definit ca:
2) lanterna.nn.Softmax	Este folosit pentru a aplica funcția softmax unui Tensor de intrare n-dimensional pentru a le redimensiona. După aceea, elementele Tensorului de ieșire n-dimensională se află în intervalul 0, 1 și suma la 1. Softmax este definit ca:
3) lanterna.nn.Softmax2d	Este folosit pentru a aplica SoftMax peste caracteristici la fiecare locație spațială.
4) lanterna.nn.LogSoftmax	Este folosit pentru a aplica funcția LogSoftmax unui Tensor de intrare n-dimensional. Funcția LofSoftmax poate fi definită ca:
5) torță.nn.AdaptiveLogSoftmaxWithLoss	Este o strategie pentru antrenarea modelelor cu spații mari de ieșire. Este foarte eficient atunci când distribuția etichetei este foarte dezechilibrată
8.	Straturi de normalizare
1) torță.nn.BatchNorm1d	Este folosit pentru a aplica normalizarea loturilor asupra intrărilor 2D sau 3D.
2) torță.nn.BatchNorm2d	Este folosit pentru a aplica normalizarea loturilor pe un 4D.
3) torță.nn.BatchNorm3d	Este folosit pentru a aplica normalizarea loturilor asupra intrărilor 5D.
4) torță.nn.GroupNorm	Este folosit pentru a aplica normalizarea grupului pe un mini-lot de intrări.
5) torță.nn.SyncBatchNorm	Este folosit pentru a aplica normalizarea loturilor asupra intrărilor n-dimensionale.
6) torță.nn.InstanceNorm1d	Este folosit pentru a aplica o normalizare a instanței peste o intrare 3D.
7) torță.nn.InstanceNorm2d	Este folosit pentru a aplica o normalizare a instanței peste o intrare 4D.
8) torță.nn.InstanceNorm3d	Este folosit pentru a aplica o normalizare a instanței peste o intrare 5D.
9) torță.nn.LayerNorm	Este folosit pentru a aplica normalizarea stratului pe un mini-lot de intrări.
10) torță.nn.LocalResponseNorm	Este folosit pentru a aplica normalizarea răspunsului local asupra unui semnal de intrare care este compus din mai multe planuri de intrare, unde canalul ocupă a doua dimensiune.
9.	Straturi recurente
1) torță.nn.RNN	Este folosit pentru a aplica un RNN Elman multistrat cu neliniaritate tanh sau ReLU la o secvență de intrare. Fiecare strat calculează următoarea funcție pentru fiecare element din secvența de intrare: ht=tanh(WlorXt+blor+Whhtt-1+bhh)
2) torță.nn.LSTM	Este folosit pentru a aplica o memorie RNN pe mai multe straturi (LSTM) la o secvență de intrare. Fiecare strat calculează următoarea funcție pentru fiecare element din secvența de intrare:
3) torță.nn.GRU	Este folosit pentru a aplica un RNN (GRU) de unitate multi-strat la o secvență de intrare. Fiecare strat calculează următoarea funcție pentru fiecare element din secvența de intrare:
4) torță.nn.RNNCell	Este folosit pentru a aplica o celulă Elman RNN cu neliniaritate tanh sau ReLU la o secvență de intrare. Fiecare strat calculează următoarea funcție pentru fiecare element din secvența de intrare: h'=tanh(Wlorx+blor+Whhh+bhh) ReLU este folosit în loc de tanh
5) torță.nn.LSTMCell	Este folosit pentru a aplica o celulă de memorie pe termen lung (LSTM) unei secvențe de intrare. Fiecare strat calculează următoarea funcție pentru fiecare element din secvența de intrare: Unde σ este funcția sigmoidă și * este produsul Hadamard.
6) torță.nn.GRUCell	Este folosit pentru a aplica o celulă GRU (Ged Recurrent Unit) la o secvență de intrare. Fiecare strat calculează următoarea funcție pentru fiecare element din secvența de intrare:
10.	Straturi liniare
1) torță.nn.Identitatea	Este un operator de identitate de substituent care este insensibil la argument.
2) torță.nn.Liniară	Este folosit pentru a aplica o transformare liniară datelor primite: y=xAT+b
3) torță.nn.Biliniar	Este folosit pentru a aplica o transformare biliniară datelor primite: y=x1Topor2+b
unsprezece.	Straturi de abandon
1) torță.nn.Dropout	Este folosit pentru regularizarea și prevenirea coadaptării neuronilor. Un factor de în timpul antrenamentului scalele de ieşire. Aceasta înseamnă că modulul calculează o funcție de identitate în timpul evaluării.
2) torță.nn.Droout2d	Dacă pixelii adiacenți din hărțile de caracteristici sunt corelați, atunci torch.nn.Dropout nu va regulariza activările și va scădea rata efectivă de învățare. În acest caz, torch.nn.Dropout2d() este utilizat pentru a promova independența între hărțile caracteristicilor.
3) torță.nn.Droout3d	Dacă pixelii adiacenți din hărțile de caracteristici sunt corelați, atunci torch.nn.Dropout nu va regulariza activările și va scădea rata efectivă de învățare. În acest caz, torch.nn.Dropout2d () este utilizat pentru a promova independența între hărțile caracteristicilor.
4) torță.nn.AlphaDropout	Este folosit pentru a aplica Alpha Dropout peste intrare. Alpha Dropout este un tip de abandon care menține proprietatea de auto-normalizare.
12.	Straturi rare
1) torță.nn.Încorporarea	Este folosit pentru a stoca cuvintele încorporate și pentru a le prelua folosind indici. Intrarea pentru modul este o listă de indici, iar rezultatul este încorporarea cuvântului corespunzătoare.
2) torță.nn.EmbeddingBag	Este folosit pentru a calcula sumele sau media „saci” de încorporare fără a instanția încorporarea intermediară.
13.	Funcția de distanță
1) torță.nn.CosineSimiliarity	Va returna asemănarea cosinusului dintre x1 și x2, calculată de-a lungul dim.
2) torță.nn.PairwiseDistance	Acesta calculează distanța perechi în loturi dintre vectorii v1, v2 folosind norma p:
14.	Funcția de pierdere
1) torță.nn.L1Pierdere	Este folosit pentru un criteriu care măsoară eroarea absolută medie dintre fiecare element din intrarea x și ținta y. Pierderea neredusă poate fi descrisă astfel: l(x,y)=L={l1,...,ln},ln=|xn-șin|, Unde N este dimensiunea lotului.
2) torță.nn.MSELoss	Este folosit pentru un criteriu care măsoară eroarea pătratică medie dintre fiecare element din intrarea x și țintă y. Pierderea neredusă poate fi descrisă astfel: l(x,y)=L={l1,...,ln},ln=(xn-șin)2, Unde N este dimensiunea lotului.
3) torță.nn.CrossEntropyLoss	Acest criteriu combină nn.LogSoftmax() și nn.NLLLoss() într-o singură clasă. Este util atunci când antrenăm o problemă de clasificare cu clasele C.
4) torță.nn.CTCLoss	Pierderea Clasificării Temporale Connectionist calculează pierderea între o serie de timp continuă și o secvență țintă.
5) torță.nn.NLLLoss	Pierderea Negative Log-Likelihood este utilizată pentru a antrena o problemă de clasificare cu clasele C.
6) torță.nn.PoissonNLLLoss	Pierderea log-probabilității negative cu distribuția Poisson a lui t target~Poisson(input)loss(input,target)=input-target*log(tinta!)tinta.
7) torță.nn.KLDivLoss	Este o măsură utilă a distanței pentru distribuția continuă și este, de asemenea, utilă atunci când efectuăm regresia directă asupra spațiului de distribuție continuă a ieșirii.
8) torță.nn.BCELoss	Este folosit pentru a crea un criteriu care măsoară Entropia încrucișată binară între țintă și rezultat. Pierderea neredusă poate fi descrisă astfel: l(x,y)=L={l1,...,ln},ln=-vn[șin*logxn+ (1-an)*log(1-xn)], Unde N este dimensiunea lotului.
9) torță.nn.BCEWithLogitsLoss	Combină un strat Sigmoid și BCELoss într-o singură clasă. Putem profita de trucul log-sum-exp pentru stabilitatea numerică combinând operația într-un singur strat.
10) torță.nn.MarginRankingLoss	Acesta creează un criteriu care măsoară pierderea intrărilor date x1, x2, doi tensori mini-loturi 1D și o etichetă tensor mini-loturi 1D y care conține 1 sau -1. Funcția de pierdere pentru fiecare probă din mini-lot este următoarea: pierdere(x,y)=max(0,-y*(x1-X2)+marja
11) torță.nn.HingeEmbeddingLoss	HingeEmbeddingLoss măsoară pierderea unui tensor de intrare x și a unui tensor de etichete y care conține 1 sau -1. Este folosit pentru a măsura dacă două intrări sunt similare sau diferite. Funcția de pierdere este definită ca:
12) torță.nn.MultiLabelMarginLoss	Este folosit pentru a crea un criteriu care optimizează o pierdere de balama multi-clasificare între intrarea x și ieșirea y.
13) torță.nn.SmoothL1Loss	Este folosit pentru a crea un criteriu care utilizează un termen pătrat dacă eroarea absolută a elementului scade sub 1 și un termen L1 în caz contrar. Este, de asemenea, cunoscut sub numele de pierdere Huber:
14) torță.nn.SoftMarginLoss	Este folosit pentru a crea un criteriu care optimizează pierderea logistică de clasificare în două clase între tensorul de intrare x și tensorul țintă y care conține 1 sau -1.
15) torță.nn.MultiLabelSoftMarginLoss	Este folosit pentru a crea un criteriu care optimizează pierderea cu mai multe etichete unul versus toate pe baza entropiei maxime între intrarea x și ținta y de dimensiune (N, C).
16) torță.nn.CosineEmbeddingLoss	Este folosit pentru a crea un criteriu care măsoară pierderea tensoarelor de intrare date x1, x2 și o etichetă tensorului y cu valorile 1 sau -1. Este folosit pentru a măsura dacă două intrări sunt similare sau diferite, folosind distanța cosinus.
17) torță.nn.MultiMarginLoss	Este folosit pentru a crea un criteriu care optimizează o pierdere de balama de clasificare multiclasă între intrarea x și ieșirea y.
18) torță.nn.TripletMarginLoss	Este folosit pentru a crea un criteriu care măsoară pierderea tripletului a unui tensori de intrare x1, x2, x3 și o marjă cu o valoare mai mare de 0. Este folosit pentru măsurarea unei similarități relative între eșantioane. Un triplet este compus dintr-o ancoră, un exemplu pozitiv și un exemplu negativ. L(a,p,n)=max{d(ai,pi)-d(ai,ni)+marja,0}
cincisprezece.	Straturi de vedere
1) torță.nn.PixelShuffle	Este folosit pentru a rearanja elementele într-un tensor de formă(*,C×r2,H,W) la un tensor de formă (*,C,H×r,W,r)
2) torță.nn.Upsample	Este folosit pentru a supraeșantiona date 1D, 2D sau 3D multicanal.
3) torță.nn.upsampling Nearest2d	Este folosit pentru a aplica supraeșantionarea vecinului cel mai apropiat 2D unui semnal de intrare compus cu mai multe canale de intrare.
4) torță.nn.UpsamplingBilinear2d	Este folosit pentru a aplica supraeșantionarea biliniară 2D unui semnal de intrare compus cu un canal de intrare multiplu.
16.	Straturi paralele de date (multi-GPU, distribuite)
1) torță.nn.DataParallel	Este folosit pentru a implementa paralelismul de date la nivel de modul.
2) torță.nn.DistributedDataParallel	Este folosit pentru implementarea paralelismului de date distribuite, care se bazează pe pachetul torch.distributed la nivel de modul.
3) torță.nn.DistributedDataParallelCPU	Este folosit pentru a implementa paralelismul de date distribuite pentru CPU la nivel de modul.
17.	Utilități
1) torch.nn.clip_grad_norm_	Este folosit pentru a tăia norma de gradient a unui iterabil de parametri.
2) torch.nn.clip_grad_value_	Este folosit pentru a tăia norma de gradient a unui iterabil de parametri la valoarea specificată.
3) torch.nn.parameters_to_vector	Este folosit pentru a converti parametrii într-un singur vector.
4) torch.nn.vector_to_parameters	Este folosit pentru a converti un vector în parametri.
5) torță.nn.greutate_normă	Este folosit pentru a aplica normalizarea greutății unui parametru din modulul dat.
6) torță.nn.remove_weight_norm	Este folosit pentru a elimina normalizarea greutății și re-parametrizarea dintr-un modul.
7) torță.nn.normă_spectrală	Este folosit pentru a aplica normalizarea spectrală unui parametru din modulul dat.
8) torță.nn.PackedSequence	Se va folosi pentru a păstra datele și lista de dimensiuni de lot a unei secvențe împachetate.
9) torch.nn.pack_padded_sequence	Este folosit pentru a împacheta un Tensor care conține secvențe captusite de lungime variabilă.
10) torch.nn.pad_packed_sequence	Este folosit pentru a completa un lot de secvențe cu lungime variabilă.
11) torch.nn.pad_sequence	Este folosit pentru a completa o listă de tensori de lungime variabilă cu valoare de umplutură.
12) torch.nn.pack_sequence	Este folosit pentru a împacheta o listă de tensori de lungime variabilă
13) torță.nn.remove_spectral_norm	Este folosit pentru a elimina normalizarea spectrală și re-parametrizarea dintr-un modul.

Referinţă:

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