Pytorch -opplæring

Pytorch er et åpen kildekodebibliotek med maskinlæring som brukes til Python. Facebooks forskerteam for kunstig intelligens opprettet opprinnelig det, og fungerte som grunnlaget for Ubers Pyro -programvare for probabilistisk programmering. Det er en matematisk verktøysett som gjør det mulig å beregne kontrastgrafbaserte modeller effektivt og automatisk.

Siden det er greit og tilpasningsdyktig, er Pytorch API populær blant akademikere og forskere, og lager nye dype læringsmodeller og applikasjoner. På grunn av den utbredte bruken, er det allerede mange utvidelser for nisjeapplikasjoner, for eksempel tekst, datamaskinvisjon og lyddata, og potensielt klare til å bruke forhåndsutdannede modeller.

Egenskaper

De viktigste egenskapene til Pytorch er:

Lett å bruke

Siden Pytorch har et intuitivt API og er avhengig av Python, anses det som relativt enkelt å bruke. Kodeutførelse gjøres enkel av denne rammen.

Python -bruk

Denne modulen samhandler sømløst med Python Data Science Stac og regnes som Pythonic. Som et resultat kan det bruke alle funksjonene og tjenestene Python -miljøet gir.

Beregningsgrafer

Pytorch tilbyr et effektivt miljø for dynamiske beregningsgrafer. Dette gir mulighet for modifisering av runtime av brukeren.

Verktøy og biblioteker

Et levende fellesskap av forskere og skapere har etablert et omfattende nettverk av verktøy og biblioteker for formidling av Pytorch og fremme avansement i felt som datasyn og forsterkningslæring.

Fordelene med Pytorch

• Det er lett å forstå og enkelt å kode fordi det er basert på Python
• Aktiverer enkel feilsøking ved hjelp av godt likt Python-verktøy
• Pytorch er enkel å skalere og har utmerket støtte på de mest populære skyplattformene
• Fokuserer det lille samfunnet på åpen kildekode
• Har muligheten til å eksportere læringsmodeller i Open Neural Network Exchange (ONNX) vanlig format

Forskjell mellom fakkel og pytorch

Torl. Det utvikles ikke lenger aktivt.

Pytorch er biblioteket basert på en fakkel siden det er greit og tilpasningsdyktig. I Pytorch indikerer “Py” Python der "fakkel" gjenspeiler det tidligere fakkelbiblioteket.

Hvordan installere Pytorch

Husk at Python er installert, spesielt versjon 3.7 eller høyere, før du konfigurerer Pytorch. Python kan installeres ved hjelp av Anaconda. Etter å ha satt opp Python -miljøet vårt, vil vi fortsette til vårt neste trinn med å installere Pytorch.

Først må vi skape et virtuelt miljø for Conda der vi ønsker å installere alle pakkene våre og etablere miljøet.

$ conda create -n pytorch python = 3.7

Conda er en miljøsjef som hjelper deg med å installere maskinlæringsprogrampakken. Hvis du må jobbe med en annen versjon av Python, trenger du ikke bytte til den. Conda vil automatisk administrere det. Du må bare bruke noen kommandoer for å gjøre miljøet ditt i henhold til ditt valg.

Hvor det er et nøkkelord for å fortelle kompilatoren å lage et nytt miljø for Pytorch som vil bruke “Python 3.7 ”versjon. Når pakkene våre blir lastet ned, vil de be om din tillatelse til å installere dem eller ikke.

Ettersom miljøet ditt er opprettet, vil det vise utdataene, som vist i følgende utdrag:

La oss komme i gang med Pytorch -installasjon:

Åpne følgende lenke og gå til Pytorch -nettstedet. Gå til fanen Komme i gang og klikk på Start lokalt.

https: // pytorch.org/bli startet/lokalt/

En sone som den i figuren under vil bli sett. Den første velgeren vil være Pytorch Build, og velg Stabil (1.12.1) Fra de gitte alternativene. Nå vil det andre velgerfeltet være ditt valg, og du kan velge OS i henhold til dine krav. Vi vil velge Windows OS fra de gitte alternativene fordi vi bruker Windows for å utføre oppgavene våre. Den tredje fanen vil være pakke. Vi vil velge konda fra de gitte alternativene. Hvis vi bruker noen annen pakke, vil vi velge den pakken.

I det nest siste alternativet velger du navnet på språket du bruker, og i vårt tilfelle vil det være Python slik at vi velger det fra de gitte alternativene. Endelig vil vi velge CPU fra de gitte alternativene fordi vi bruker CPU som vår databehandlingsplattform. Hvis vi bruker en annen plattform som CUDA, velger du CUDA.

Etter å ha valgt alle alternativene fra velgerne gitt ovenfor, vises en kommando i feltet nedenfor. Kopier den kommandoen og kjør den kommandoen i din Conda -kommando -ledetekst.

I forrige kommando vil Conda bli bedt om å installere Pytorch og andre biblioteker, Torchvision og Torchaudio, hvor Torchvision er biblioteket til Python. Den ble designet for å gjøre testing og studier innen datasyn enklere. Den har modellarkitekturer, vanlige bildetransformasjoner og andre populære datasett for datamaskinvisjon.

Torchaudio er også en pakke med Pytorch, og den ble bygget for lyd- og signalbehandling av datamaskiner. Den har også populære datasett, I/O og vanlige lydtransformasjoner.

Når alle pakkene våre lastes ned, vil det be om din tillatelse om du vil fortsette med det eller ikke.

Nå, flytter vi til neste trinn, aktiver Pytorch -pakkene våre. Ved å gjøre dette vil vi kjøre følgende kommando i Anaconda -ledeteksten:

$ conda aktiverer pytorch

Nå, aktivering av Pytorch -pakkene våre ved hjelp av kommandoen som tidligere er nevnt i denne aktiveringen, er nøkkelordet som brukes til å instruere Conda for å aktivere Pytorch -biblioteket vi allerede har installert.

Vi kan bekrefte ved å starte Python at hvis den kjører, vil den vise følgende utgang:

Etter det må vi importere fakkel i den; Hvis den viser en modul som ikke er funnet feil, betyr dette at installasjonen din ikke var riktig. I dette tilfellet var installasjonen riktig, så den viste ingen feil.

Nå kan vi opprette en fakkelsensor for å sjekke om det fungerer riktig for å gjøre det; la oss si:

$ x = fakkel.Rand (3)
$ print (x)

I forrige kommando opprettet vi en variabel “x” og tildelte den til Value Torch.Rand, der Rand indikerer en tilfeldig verdi. Deretter viste vi fakkelutgangen for den ved hjelp av utskriftsfunksjonen og passerte den vår variable “x”. Følgende skjermbilde viser hvordan tensorverdier vises:

Nå, sjekker fakkelversjonen, importerer vi fakkel, og bruker utskriftsfunksjonen, vil vi passere verdien “Torch__Version__” for å sjekke den.

$ import fakkel
$ print (fakkel.__versjon__)

Her er utgangen for følgende kommando, som vist i forrige figur. Og nå er Pytorch -miljøet vårt med hell installert for vår bruk.

Pytorch dyp læringsmodell livssyklus

Prosjekter som involverer maskinlæring er ikke enkle; De involverer en pågående syklus for å forbedre data, modell og evaluering. Denne syklusen er avgjørende for å lage en maskinlæringsmodell siden den understreker bruken av simulering og resultater for å forbedre datasettet ditt.

I mer enn ti år har dyp læring vært et hovedtema og har bidratt til markedets økte fokus på ML. Utviklingen av mange verktøy for å hjelpe til med å produsere ML -modeller har fått ML -bransjen til å oppleve.

5 hovedtrinn for dyp læringsmodell Livssyklus er:

1. Utarbeide data
2. Modal definerende
3. Trene modalen
4. Modal evaluering
5. Spådommer

Eksempel 1

I dette eksemplet vil vi bruke Torchvision Library med et forhåndsinnlastet "FashionMnist" datasett ved hjelp av Torchvision Library of Pytorch, som har gjenstander i den virkelige verden.

Når det gjelder å jobbe med data, bruker Pytorch sine to hovedelementer, som er fakkel.benyttede.data.Dataloader og fakkel.benyttede.data.Datasett, slik at vi kan bruke dataene dine eller forhåndsbelastede datasett. Data Loader pakker en iterable rundt datasettet for å gjøre det enkelt å skaffe prøvene, som datasettet bruker for å lagre prøvene og deres relaterte etiketter.

UTENSOR brukes til forbedring og transformasjon av bilde, mens NN -pakken spesifiserer en samling av praktiske tapsfunksjoner som vanligvis brukes. FashionMnist Dataset fungerer for bilder med elementer fra 0-255. Du kan også skrive tilpassede transformasjoner i henhold til dine behov. La oss sjekke ut koden til dette scenariet i følgende bilde:

I den øvre koden har vi tildelt et datasett av FashionMnist til vår trening_data. Dette datasettet tilordnet trening_data består av mange visjonsdata i den virkelige verden, for eksempel CIFAR og COCO. Vi vil bruke det fashionmnist -datasettet i dette tilfellet. Alle Torchvision -datasettene krever to parametere. Den ene er transformert, og den andre er Target_Transform. Disse to parametrene endrer etikettene og prøvene.

Resultatene vist i det medfølgende figuren vises etter at koden er kjørt. Det begynner å laste ned datasettet fra biblioteket.

Nå lastes datasettet lastet ned etter utførelsen av koden vår. Vi vil gi datasettet som en parameter til DataLoader. Dette vil hjelpe oss i prøvetaking, stokking, databelastning av multiprosess og batching automatisk. I vårt tilfelle tildeler vi 64 til Batch_Size. Som et resultat definerer vi 64 batchstørrelser. Hvert element i Dataloader Iterable vil kunne returnere en utgang fra en gruppe på 64 etiketter og funksjoner.

Vi har satt toget til å være sant fordi det setter modulen. Nedlastingen er også satt til ekte modus, fordi vi må laste ned datasettet for å trene modulen vår ved hjelp av det datasettet. Vi har gitt data til vår rotparameter fordi vi vil gi informasjonen til modulen vår i form av data som vi vil laste ned fra rutensorpakken.

Etter å ha utført koden vår, kan vi se i output at den har skrevet ut formene til X og Y i henhold til våre tidligere argumenter. Den vil laste ned bildene.

Nå, som beveger oss mot modal skapelse, vil vi lage en klasse som heter Neural Network som vil arve NN. Modulen er en parameter. Vi vil lage en funksjon som heter init; I denne funksjonen vil vi definere lagene i nettverket. Deretter vil vi opprette en funksjon med navnet fremover når navnet tydeliggjør dets formål. Vi skal indikere hvordan dataene skal overføres via nettverket i den fremre funksjonen.

Lineær er en klasse av NN -bibliotek som bruker en lineær transformasjon på dataene vi gir til den. Vi passerer 28*28 som antall dimensjoner til lineær klasse. RELU er en funksjon på NN -pakker, som håndterer de negative elementene ved å erstatte dem med 0. For å fremskynde hele prosessen for det nevrale nettverket, bruker vi ressursene på grafikkortet vårt hvis de er tilgjengelige for utnyttelse. La oss sjekke ut koden til dette scenariet i det følgende pålagte bildet:

Init -funksjonen er initialiseringsmetoden i pytorch. Det kreves å la Pytorch få katalogene som inneholder biblioteker. I dette passerte vi det selvfunksjon. Mens vi i den fremre funksjonen passerer inngangstensorer som parametere, og den fremre funksjonen returnerer utgangstensorer ved å beregne inngangstensorene. I dette passerer vi to parametere, "selv" og "x", til den fremre funksjonen. Fremoverfunksjonen definerer også hvordan modulen din vil fungere fra inngang til utdata.

Etter det vises utdataene fra den forrige koden i følgende skjermbilde:

Etter prosessen vi utførte i de foregående trinnene, vil vi trene modellen vår. Vi må bruke en optimalisator og en tapsfunksjon for å oppnå dette. En prosedyre for tapsfunksjon bestemmer avviket mellom en algoritmens nåværende utgang og forventet utgang. Optimizer hjelper systemet med å velge det beste valget fra et sett med mulige alternativer som er enkle og ikke utnytte begrensninger. La oss sjekke ut koden til dette scenariet i det festede bildet som vises nedenfor:

Epoch er en parameter som spesifiserer antall ganger en læringsalgoritme vil løpe gjennom datasettet vi har gitt for trening. I vårt tilfelle har vi satt det til 5, noe som betyr at det vil gå gjennom datasettet vårt 5 ganger under trening.

Etter å ha initialisert epoker, vil vi bruke en for loop, som vil kjøre antall ganger "t" som vi har erklært i epoker. I denne sløyfen vil den utføre den trente funksjonen 5 ganger og vil utføre den. Etter at all utførelsen av "for sløyfe" er gjort, vil den skrive ut teksten "Done".

Følgende utdrag viser utdataene fra epokene trente funksjon:

Eksempel 2

I dette tilfellet vil det å løse problemet med å montere y = sin (x) med en tredje ordens polynom vil være tilstrekkelig.

Metode 1

Pytorch-levert optimpakke vil bli brukt i denne teknikken. "Lommelykt.Optim ”er en Pytorch -pakke som er ansvarlig for å implementere forskjellige optimaliseringsteknikker. Flertallet av ofte brukte teknikker er allerede implementert, og grensesnittet er tilstrekkelig åpent for at fremtidig enkel integrering av mer komplekse er også mulig. Ved å endre tensorene som inneholder lærbare parametere manuelt med fakkel.Ingen grad, vektene på modellene våre () blir oppdatert.

Vi vil også bruke NN -pakken for å erklære vår modal, men vi vil bruke RMSPOP for å optimalisere modellen fordi den gir fakkelpakken som er levert av Optim.

La oss gå videre til koden vår for å lage en tensor som er ansvarlig for å holde data for inngang og utdata. I vårt tilfelle opprettet vi to variabler, “A” og “B”. Deretter vil vi definere inngangstensorene som heter “var” og “myvar”, som er inngangstensorer x^, x^2 og x^3.

Etter det vil vi erklære modal- og tapsfunksjoner ved hjelp av NN -pakken. Lag en optimaliserer ved hjelp av optimpakken for å endre modellens vekter på våre vegne. RMSPROP vil bli brukt i dette tilfellet; Optimpakken inkluderer mange andre optimaliseringsteknikker. RMSProp Constructors første inngang instruerer optimaliseringen som tensorer den skal endres. Lag en optimaliserer ved hjelp av optimpakken for å endre modellens vekter på våre vegne. RMSPROP vil bli brukt i dette tilfellet; Optimpakken inkluderer mange andre optimaliseringsteknikker. Koden for den forrige forklaringen finner du i følgende Spyder -skjerm:

Så i det følgende trinnet vil vi beregne den forutsagte y ved å passere det Myvar:

$ y_pred = modal (myvar)

I den er y_predicat variabelen som vi tildeler modalfunksjonen som "myvar" -verdien passerer. Tapet vil da bli beregnet og vist. Dette er forårsaket av at gradienter er dynamisk samlet i buffere når som helst.bakover () påberopes.

tap.bakover () vil bestemme tapsgradienten med hensyn til modalen. Når en optimalisers trinnfunksjon påberopes, oppdateres parametrene. Inngangsfunksjonene til lineære lag multipliseres med vektmatrisen for å generere utgangsfunksjonene. Inngangsfunksjonene føres til et lineært lag som en endimensjonal tensor som er blitt revet, og de multipliseres med vektmatrisen. På slutten av koden vil den vise utgangen som et resultat i form av ligningen.

Metode 2

I den følgende metoden vil vi bruke Tensor- og Autograd -pakker. Importer først våre fakkel- og matematikkbiblioteker for dette programmet og deretter definere variablene våre "dtype". Her tildelte vi verdien fakkel.Flyte som utført i forrige eksempel og definerte variabelen "enheten". Vi tildeler igjen verdien fakkel.enhet (“CPU”) som brukes til å definere plattformen som skal brukes.

For å holde innganger og utganger, lag tensorer. Forutsatt at det krever grad = falsk, trenger ikke bakoverpasset å beregne gradienter om disse tensorene som standard. Lage vekter ved hjelp av tilfeldige tensorer. Vi krever fire vekter for et polynom av tredje orden: y = a + b x + c x^2 + d x^3 innstillingskrav. Vi ønsker å beregne gradienter angående disse tensorene under bakoverpasset, noe som er indikert med verdien _grad = true.

Beregne og vise tap ved bruk av tensorfunksjoner. Tap blir en tensor med skjemaet (1,) tap. Tapets skalarverdi returneres av varen (). Koden for den forrige forklaringen finner du i følgende Spyder -skjerm:

I dette tilfellet må den tilbakestående passet til vårt nevrale nettverk administreres manuelt. Det er ikke fysisk vanskelig for det enkle to-lags nettverket å gjøre det. Imidlertid kan det raskt bli komplisert for store komplekse nettverk. Heldigvis kan vi bruke automatisk differensiering for å mekanisere prosessen med en bakoverpass i nevrale nettverk. Autograd -biblioteket i Pytorch gir denne funksjonaliteten veldig presist; Mens du bruker Autograd, vil fremoverpasset til et nettverk karakterisere en beregningsgraf. Grafen vil ha noder og kanter; Tensorer er representert ved hjelp av noder, og kanter representerer metodene som vil returnere output -tensorer ved å ta inngangstensorer som argumenter.

Å lese denne grafen hjelper deg med å beregne graderinger enkelt. Dette virker som en vanskelig oppgave, men i virkeligheten er denne praksisen veldig enkel og grei. Hvis “X” er en tensor og attributtet “krever grad” til True. Derfor er X en tensor som adresserer en node i en beregningsgraf. x.grad er en annen tensor som holder en skråning av "x" for en viss skalarverdi. Her demonstrerer vi montering av en sinusbølge med en tredje ordens polynom ved bruk av pytorch-tensorer og autograd. Nå er det ikke behov for at vi manuelt utfører bakoverpausen gjennom nettverket.

Metode 3

I dette eksemplet vil vi bruke Numpy -modulen. Numpy er et Python-bibliotek for programmeringsspråket som støtter betydelige, flerdimensjonale matriser og matriser. I tillegg er en betydelig mengde matematiske operasjoner på høyt nivå for å operere på disse matriser. Numpy er en generisk plattform for å beregne vitenskapelige operasjoner; Det involverer ikke dyp læring eller databehandlingsgregener.

Ved hjelp av numpy operasjoner kan vi enkelt passe til en tredje ordens polynom i en "synd" -funksjon. For å gjøre det, vil vi først importere biblioteker numpy og matte. Matematikk er pakken som brukes til å importere matematiske operasjoner. La oss sjekke ut koden til dette scenariet i følgende bilde:

Vi initialiserte først to variabler kalt “var1” og “var2” og tildelte funksjonene deres. Her, np.Linspace -funksjonen er en Python -metode som hjelper oss å lage numeriske sekvenser. Det hjelper oss med å generere lineær-avstandsvektorer. Det er det samme som tykktarmstegnet, men den eneste forskjellen mellom tykktarmstegnet, og det er at det gir oss direkte kontroll over antall poeng. Til denne funksjonen passerte vi tre parametere som er “-MATH.pi ”,“ Matematikk.pi ”og“ 200 ”, der 200 er området beregningen vil bli gjort. Og den andre funksjonen vi sendte til var2 er “NP.Sin (var1) ”, som brukes til å beregne sinus for verdiene som vil bli lagret i“ var1 ”.

Deretter initialiserte vi fire variabler kalt “A”, “B”, “C” og “D” til disse variablene vi passerte tilfeldige verdier. Deretter initialiserte vi en for loop som vi passerte variabel “t”, noe som indikerte tiden og området til 200.

Etter det, definer en annen variabel, "var2_pred", som vi vil tildele den matematiske operasjonen for beregning av aggregat og deretter overføre den til variabelen som heter "tap". Tapet vil være ansvarlig for å beregne tapet "var2_pred".

Flytting til neste trinn, der vi brukte IF -uttalelsen, som vil være ansvarlig for å beregne beregningen av “T%10 == 9”, vil den ta modus for “T” med verdien 10 og øke den med 9. Det vil skrive ut tapet av disse verdiene oppnådd fra forrige IF -uttalelse.

Etter alle disse beregningene der for -loopen slutter, vil den oppsummere hele verdiene, og den siste utskriftsoperasjonen blir beregnet på slutten av for -loopen og vil bli vist som et resultat, som vist i utdraget nedenfor:

Metode 4

I dette kodestykket bruker vi Tensor -pakken. En numpy matrise og en pytorch-tensor er teoretisk likeverdig fordi en tensor er en flerdimensjonal matrise, og Pytorch tilbyr en rekke metoder for å jobbe med dem. Tensorer er et vitenskapelig databehandlingsverktøy som kan overvåke gradienter og beregningsgrafer i bakgrunnen i bakgrunnen i bakgrunnen. Pytorch -tensorer kan bruke GPUer for å få fart på sine numeriske operasjoner, i motsetning til Numpy. En pytorch -tensor kan utføres på en GPU i noen få enkle trinn.

I dette kodestykket importerte vi to biblioteker, fakkel og matte. Siden vi bruker en fakkel i denne koden og matematiske funksjonaliteter, definerte vi en variabel med navnet "DType". Vi tildelte datatyper fakkel.flyte fordi vi utfører matematiske operasjoner som vil returnere verdier i poeng. For å lagre desimalverdier bruker vi datatype float.

Så erklærte vi en annen variabel som heter "Enhet" med tildeling av verdi fakkel.enhet (“CPU”) fordi vi valgte CPU som vår plattform i Pytorch -installasjonen. Fremover har vi initialisert to variabler kalt var1 "og" var2 "og tildelt dem den samme funksjonen som vi tildelte i forrige eksempel. Deretter blir det brukt å lage fire variabler som er "A", "B", "C" og "D" for å lage tilfeldige tensorer. Hver har sin unike form; Vi har også passert datatype -enheten og dtypen, som vil bli initialisert i begynnelsen av koden vår. Så den vil bruke ressursene til vår CPU og vil ta verdier i form av desimaler. Det er indikert at vi har tenkt å beregne gradienter om slike tensorer under omvendt passering ved å oppgi at det krever grad = sant. La oss sjekke ut koden til dette scenariet i det følgende pålagte bildet:

Så erklærte vi en læring_rate = 1e-6. Læringshastighet er også en hyperparameter som brukes til opplæring av nevrale nettverk. Den har en veldig liten verdi som må være større enn 0.0 og mindre enn 1.0, noe som betyr at det må være en positiv verdi. Læringsstempoet øker med den økende læringsraten.

Etter det vil vi åpne en sløyfe som vil bli utført 200 ganger og vil utføre matematiske operasjoner på variablene våre. Uansett hvor t%100 blir lik 99, vil sløyfen skrive ut antall ganger den blir utført og stoppet. Etter det vil resultatet bli publisert som vår iterasjon avsluttes, som vist i følgende skjermbilde:

Metode 5

I denne metoden vil vi lage vår autograd -funksjon ved hjelp av Pytorch underklasser. Hver primær autograd er to metoder som fungerer på tensorer. Fremoverfunksjonen tar inngangstensorer og beregner utgangstensorer fra dem. I Pytorch kan vi utvilsomt karakterisere vår autograd -operatør ved å beskrive en underklasse.Autograd.funksjon og kjøre fremover og bakover tilnærminger.

Nå anskaffes output -tensorene som parametere til bakoverfunksjonene med noen skalarverdier. Pytorch letter oss å definere vår autograd -operatør ved å gjøre det mulig for oss å lage en underklasse som analyserer gradienten til inngangstensorene med hentydning til de samme skalarverdiene. Nå kan vi bruke vår autogradoperatør ved å initialisere en konstruktør og kalle den en metode. Så vil vi passere tensoren med inngangsdata som en parameter til den konstruktøren.

I det følgende eksempel spesifiserer vi modalen vår som:

$ y = a+b p_3 (c+dx)
y = a+bp3 (c+dx)
i stedet for
y = a+bx+cx^2+dx^3
y = a+bx+cx2+dx3

Vi komponerer vår tilpassede autograd -metode ved å behandle fremover og bakover av P3 og bruke den til å utføre vår modell. Koden for følgende forklaring finner du på Spyder -skjermen.

Ved å underklasse fakkelen, kan vi implementere våre unike autograd -funksjoner.Autograd. Dermed fungerer og utnytter fremover- og bakoverpasset som bruker tensorer. Vi får en tensor som holder inngangen under fremoverpasset og leverer en tensor som inneholder utgangen. Et kontekstobjekt kalt CTX kan brukes til å lagre data for bruk i bakoverberegning.

Tensorer kan opprettes for å lagre inngang og utgang. Forutsatt at det krever grad = falsk, trenger ikke bakoverpasset å beregne gradienter om disse tensorene som standard.

Lage vekter ved hjelp av tilfeldige tensorer. For å garantere konvergens, bør vektene for dette eksemplet introduseres rimelig nær det nøyaktige resultatet: y = a + b * p3 (C + d * x). Det er indikert at vi har til hensikt å generere en gradient angående disse kartleggingene under en bakoverpasning etter innstilling som krever grad = sant.

Følgende bilde viser utgangen som den forrige koden genererte:

Metode 6

Her vil vi bruke nn modulen for å løse dette problemet. Etter å ha importert våre ønskede bibliotek. Dette eksemplet kan betraktes som et lineært lag nevralt nettverk siden den resulterende utgangen er en lineær funksjon av (x, x2, x3). La oss sjekke ut koden til dette scenariet er følgende påførte bilde:

La oss gjøre tensoren (x, x2, x3) klar. Siden P har form (3) og x.Unsqueeze (-1) har struktur (200, 1), streaming semantikk vil bli brukt til å produsere en tensor av form i denne situasjonen (200, 3). For å konstruere modellen vår som en serie lag, bruk NN -pakken. NN er en modul som bruker andre moduler sekvensielt for å oppnå sin utgang, kjent som en sekvensiell modul. Den lineære modulen opprettholder interne tensorer for sin skjevhet og vekt og bruker en lineær funksjon for å beregne utgangen fra inngang. For å beregne bakoverpasset, bruk autograd.

en.grad, b.grad vil følge denne samtalen. Tensorer som holder gradienten av et tap angående bokstaver A, B, C og D er betegnet som C.grad og d.grad, henholdsvis. Vi benyttet Mean Squared Feil (MSE) som vår tapsfunksjon, som er definert i NN -pakken sammen med andre fremtredende tapsfunksjoner.

Fremover pass: Ved å gi modellen X, beregne den forventede y. __Call__ -operatøren utvides med modulobjekter, slik at du kan kalle dem akkurat som funksjoner. Når du gjør det, gir du modulen en tensor med inngangsdata, og den returnerer en tensor med forventet utgang. Duplikat og utskriftstap Tapfunksjonen gir en tensor som inneholder tapet etter å ha mottatt tensorer fra oss som inneholder de sanne og forventede verdiene til y.

Beregn gradienten av et tap angående hver lærbare modellparameter under bakoverpasset. På grunn av den interne lagringen av hver modulens egenskaper i tensorer som krever en grad satt til sann, vil denne funksjonen beregne gradienter for alle lærbare modellparametere. Du kan få tilgang til modellens innledende lag ved å velge det første elementet fra en liste.

Endelig vises resultatet ved hjelp av utskriftsfunksjonen når hele iterasjonen utføres vellykket.

Metode 7

Lommelykt.NN -modulen er vanligvis Pytorchs viktigste byggestein. Først, definer en NN.Modulobjekt, og kaller den fremoverfunksjonen for å kjøre det. Denne driftsmetoden er objektorientert. Et helt tilkoblet RELU -nettverk inkluderer ett skjult lag som.

I dette tilfellet er modellen definert som en spesifikk modulunderklasse. Du må definere modellen din på denne måten når du vil at den skal være mer sammensatt enn en enkel liste over alle de for tiden eksisterende modulene. Koden for den forrige forklaringen finner du i følgende Spyder -skjerm:

Beregn deretter bakoverpasset ved hjelp av autograd. Metoden vil bestemme tapsgradienten for alle tensorer med nødvendig grad = sant. EN.grad, b.grad vil følge denne samtalen. Tensorer som holder gradienten av tapet angående bokstaver A, B, C og D er betegnet som C.grad og d.grad, henholdsvis. Vi kan også definere en tilpasset funksjon i Pytorch.

Etter å ha opprettet klasse Polynomial3, vil vi erklære tensorer for å holde inngang og output. Fire argumenter er opprettet og tilordnet som medlemsparametere i funksjonen. Når den brukes med moduler, har underklassen av tensorer kjent som en parameter en svært unik eiendom. Når du blir tildelt som modulattributter, blir parameteren automatisk inkludert i listen over modulens parametere og vil vises i modulens parameters liste, e.g., i parametere () iterator. Parametrene () metoden i hver nn.Modulen henter modulens trenbare variabler. Disse variablene må eksplisitt defineres.

Fremoverfunksjonen krever en tensor med inndata og en tensor av utgangsdata. Vi kan bruke vilkårlige operatører på tensorene og modulene definert i konstruktøren. Bygg en optimalisator og vår tapsfunksjon. De trenbare parametrene, som er modellmedlemmer og er spesifisert med fakkel.nn.Parameter i SGD -konstruktøren vil bli inkludert i Call to Model.parametere (). Deretter beregner du den forutsagte y (y_pred) og pass det variabelen "var".På slutten vil nullgradientene automatisk utføre bakoverpasset og utføre vektene.

Stokastisk gradientavstamning (SGD) er en optimaliserer som tilhører gradient nedstigningsfamilien og er en kjent optimaliseringsteknikk som brukes i dyp læring og maskinlæring. Begrepet "stokastisk" refererer til et system koblet til eller koblet med tilfeldig sannsynlighet i SGD Optimizer.

Til syvende og sist vil vi beregne tapet og skrive det ut ved å tilordne det kriterietfunksjonen som er ansvarlig for beregning av tap. Vi passerte den forutsagte y og modalen som vi trente. Erklærer deretter om uttalelse som beregner modus med 10 av variable "t" -verdier. Deretter vil det øke den med 9, og den resulterende verdien av T sendes til utskriftsfunksjonen som tapet vil bli beregnet.

På slutten av koden vil resultatet bli utført med hell, som vist i følgende figur:

Konklusjon

Bruken av Pytorch API for typiske aktiviteter med dyp læringsmodell er opplæringsens sentrale mål. Informasjonen du har studert i denne artikkelen, skal gjøre det lettere å legge sofistikerte Pytorch -konsepter du kan ha tenkt på og lære Pytorch -moduler fra grunnleggende installasjon av Pytorch på Python til den komplekse treningen av en modell. Vi har også diskutert de forskjellige måtene å implementere et enkelt eksempel ved å bruke forskjellige moduler, numpy, fakkel -tensor, fakkel og autograd, ved å etablere en ny autograd -funksjon, optimalfunksjon, nn -moduler, og også den tilpassede NN -modulen. Plattformen som brukes til å utføre koden vår er Spyder; Du kan bruke andre plattformer, for eksempel Conda, Jupiter og Linux.