Tutorial Pytorch

Pytorch è una libreria open source di machine learning utilizzato per Python. Il team di ricerca sull'intelligenza artificiale di Facebook inizialmente lo ha creato, fungendo da base per il software Pyro di Uber per la programmazione probabilistica. È un kit di strumenti matematici che consente di calcolare i modelli basati su grafici di contrasto in modo efficace e automatico.

Dal momento che è semplice e adattabile, l'API Pytorch è popolare tra accademici e ricercatori, creando nuovi modelli e applicazioni di apprendimento profondo. A causa dell'uso diffuso, ci sono già numerose estensioni per applicazioni di nicchia, come testo, visione artificiale e dati audio e modelli pre-addestrati potenzialmente pronti all'uso.

Caratteristiche

Le caratteristiche chiave di Pytorch sono:

Facile da usare

Poiché Pytorch ha un'API intuitiva e si basa su Python, è considerato relativamente facile da usare. L'esecuzione del codice è semplice da questo framework.

Uso di Python

Questo modulo interagisce perfettamente con il Python Data Science Stac ed è considerato pitonico. Di conseguenza, può utilizzare tutte le funzionalità e i servizi forniti dall'ambiente Python.

Grafici computazionali

Pytorch offre un ambiente efficace per i grafici computazionali dinamici. Ciò consente la modifica di runtime da parte dell'utente.

Strumenti e librerie

Una vivace comunità di ricercatori e creatori ha creato una rete completa di strumenti e biblioteche per la diffusione di Pytorch e la promozione dell'avanzamento in campi come la visione artificiale e l'apprendimento del rinforzo.

Benefici di Pytorch

• È facile da capire e semplice da codificare perché si basa su Python
• Abilita il semplice debug utilizzando strumenti Python apprezzati
• Pytorch è semplice da ridimensionare e ha un eccellente supporto sulle piattaforme cloud più popolari
• Focalizza la sua piccola comunità sull'open-source
• Ha la capacità di esportare modelli di apprendimento nel formato comune di scambio di rete neurale aperta (ONNX)

Differenza tra torcia e Pytorch

Torch (Torch7) è una libreria di apprendimento automatico freeware e un framework di calcolo scientifico basato sul linguaggio di programmazione e in genere accessibile utilizzando l'interfaccia LUA. Non viene più sviluppato attivamente.

Pytorch è la biblioteca basata su una torcia poiché è semplice e adattabile. A Pytorch, "Py" indica il Python in cui la "torcia" riflette la sua precedente biblioteca di torce.

Come installare Pytorch

Ricorda che Python è installato, in particolare la versione 3.7 o superiore, prima di configurare Pytorch. Python può essere installato utilizzando Anaconda. Dopo aver impostato il nostro ambiente Python, procederemo al nostro prossimo passo dell'installazione di Pytorch.

Innanzitutto, dobbiamo creare un ambiente virtuale per Conda in cui vogliamo installare tutti i nostri pacchetti e stabilire l'ambiente.

$ conda create -n pytorch python = 3.7

Conda è un gestore ambientale che ti aiuta a installare il pacchetto del programma di apprendimento automatico. Se devi lavorare con un'altra versione di Python, allora non devi passare ad esso. Conda lo gestirà automaticamente. Devi solo usare alcuni comandi per creare il tuo ambiente secondo la tua scelta.

Dove creare è una parola chiave per dire al compilatore di creare un nuovo ambiente per Pytorch che utilizzerà il "Python 3.Versione da 7 ". Quando i nostri pacchetti vengono scaricati correttamente, chiederà il tuo permesso di installarli o no.

Man mano che il tuo ambiente viene creato correttamente, visualizzerà l'output, come mostrato nel seguente frammento:

Iniziamo con l'installazione di Pytorch:

Apri il seguente link e vai al sito Web Pytorch. Vai alla scheda Inizia e fai clic su Avvia localmente.

https: // pytorch.Org/Get-Started/localmente/

Si vedrà una zona come quella nella figura sottostante. Il primo selettore sarà Build Pytorch e seleziona stabile (1.12.1) Dalle opzioni indicate. Ora, il secondo campo selettore sarà la tua scelta e puoi selezionare il sistema operativo secondo le tue esigenze. Selezionare Windows OS dalle opzioni fornite perché stiamo utilizzando Windows per eseguire le nostre attività. La terza scheda sarà un pacchetto. Sceglieremo Conda dalle opzioni fornite. Se utilizziamo qualsiasi altro pacchetto, selezioneremo quel pacchetto.

Nella seconda ultima opzione, seleziona il nome della lingua che stai usando e, nel nostro caso, sarà Python in modo da selezionarlo dalle opzioni fornite. Finalmente, selezioneremo la CPU dalle opzioni fornite perché stiamo utilizzando la CPU come piattaforma informatica. Se stiamo usando qualche altra piattaforma come CUDA, seleziona CUDA.

Dopo aver selezionato tutte le opzioni dai selettori sopra indicati, un comando verrà mostrato nel campo seguente. Copia quel comando ed esegui quel comando nel prompt dei comandi Conda.

Nel comando precedente, Conda verrà chiesto di installare Pytorch e altre librerie, Torchvision e Torchaudio, dove Torchvision è la biblioteca di Python. È stato progettato per semplificare i test e lo studio nel campo della visione artificiale. Ha architetture modello, trasformazioni di immagini comuni e altri set di dati popolari per la visione artificiale.

Torchaudio è anche un pacchetto di Pytorch ed è stato costruito per l'elaborazione audio e del segnale dei computer. Ha anche set di dati popolari, I/O e trasformazioni audio comuni.

Quando tutti i nostri pacchetti vengono scaricati, chiederà il tuo permesso se procedere o no.

Ora, passando al nostro prossimo passo, attiva i nostri pacchetti Pytorch. In tal modo, eseguiremo il seguente comando nel prompt dei comandi Anaconda:

$ Conda Attiva Pytorch

Ora, attivare i nostri pacchetti Pytorch utilizzando il comando precedentemente menzionato in questa attivata è la parola chiave utilizzata per istruire la Conda ad attivare la libreria Pytorch che abbiamo già installato.

Possiamo verificare avviando Python che se è in esecuzione, visualizzerà il seguente output:

Dopodiché, dobbiamo importare la torcia in essa; Se visualizza un modulo non trovato errore, ciò significa che l'installazione non era corretta. In questo caso, l'installazione era corretta, quindi non ha visualizzato alcun errore.

Ora possiamo creare un tensore di torcia per verificare se funziona correttamente per farlo; diciamo:

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

Nel comando precedente, abbiamo creato una variabile "X" e l'abbiamo assegnata alla torcia di valore.Rand, dove Rand indica un valore casuale. Quindi abbiamo visualizzato l'uscita della torcia per esso usando la funzione di stampa e passandola la nostra variabile "X". La seguente screenshot mostra come vengono mostrati i valori del tensore:

Ora, controllando la versione della torcia, importa la torcia e utilizzando la funzione di stampa, passeremo il valore "Torch__Version__" per verificarla.

$ import Torch
$ print (torcia.__versione__)

Ecco l'output per il seguente comando, come mostrato nella figura precedente. E ora, il nostro ambiente Pytorch è installato con successo per il nostro uso.

Pytorch Deep Learning Model Life Cycle

I progetti che coinvolgono l'apprendimento automatico non sono semplici; Coinvolgono un ciclo in corso per migliorare i dati, il modello e la valutazione. Questo ciclo è essenziale per la creazione di un modello di apprendimento automatico poiché sottolinea l'uso di simulazione e risultati per migliorare il set di dati.

Per più di dieci anni, Deep Learning è stato un argomento importante e ha contribuito alla maggiore attenzione del mercato a ML. Lo sviluppo di molti strumenti per aiutare nella produzione di modelli ML ha causato l'esperienza dell'industria ML.

5 Passaggi principali per il modello di vita del modello di apprendimento profondo sono:

1. Preparazione dei dati
2. Definizione modale
3. Addestrare il modale
4. Valutazione modale
5. Previsione

Esempio 1

In questo esempio, useremo la libreria di TorchVision con un set di dati "Fashionmnist" precaricato usando la libreria TorchVision di Pytorch, che ha oggetti del mondo reale.

Quando si tratta di lavorare con i dati, Pytorch utilizza i suoi due elementi principali, che sono torce.utils.dati.Dataloader e torcia.utils.dati.Set di dati, che ci consente di utilizzare i dati o set di dati precaricati. Il caricatore di dati avvolge un iterabile atto.

Totensor viene utilizzato per il miglioramento e la trasformazione delle immagini, mentre il pacchetto NN specifica una raccolta di funzioni pratiche di perdita che vengono generalmente impiegate. Il set di dati FashionMnist funziona per immagini con elementi che vanno da 0-255. Puoi anche scrivere trasformazioni personalizzate in base alle tue esigenze. Dai un'occhiata al codice di questo scenario nella seguente immagine:

Nel codice superiore, abbiamo assegnato un set di dati di FashionMnist al nostro allenamento_data. Questo set di dati assegnato a training_data è costituito da molti dati di visione del mondo reale, come CIFAR e COCO. In questo caso impiegheremo il set di dati FashionMnist. Tutti i set di dati TorchVision richiedono due parametri. Uno è trasformato e l'altro è target_transform. Questi due parametri modificano le etichette e i campioni.

I risultati mostrati nella figura di accompagnamento compaiono dopo l'esecuzione del codice. Inizierà a scaricare il set di dati dalla libreria.

Ora, il set di dati viene scaricato dopo l'esecuzione del nostro codice. Passeremo il set di dati come parametro a DataLoader. Questo ci aiuterà a campionamento, mescolamento, caricamento dei dati del multiprocesso e batching automaticamente. Nel nostro caso, stiamo assegnando 64 al nostro batch_size. Di conseguenza, stiamo definendo 64 dimensioni batch. Ogni elemento di Dataloader Iteble sarà in grado di restituire un output di un lotto di 64 etichette e funzionalità.

Abbiamo impostato il treno per essere vero perché imposta il modulo. Il download è anche impostato su TRUE Modalità, perché dobbiamo scaricare il set di dati per addestrare il nostro modulo con l'aiuto di quel set di dati. Abbiamo passato i dati al nostro parametro root perché passeremo le informazioni al nostro modulo sotto forma di dati che scaricheremo dal pacchetto Totensor.

Dopo aver eseguito il nostro codice, possiamo vedere nel nostro output che ha stampato le forme di X e Y secondo i nostri argomenti passati. Scaricherà le immagini.

Ora, muovendosi verso la creazione modale, creeremo una classe denominata Neural Network che erediterà NN. Il modulo è un parametro. Creeremo una funzione denominata init; In questa funzione, definiremo i livelli della rete. Successivamente, creeremo una funzione con il nome in avanti mentre il nome chiarisce il suo scopo. Indicheremo come i dati verranno trasferiti tramite la rete nella funzione in avanti.

Lineare è una classe di libreria NN che applica una trasformazione lineare ai dati che ci passiamo. Passiamo 28*28 come numero di dimensioni alla classe lineare. Relu è una funzione sui pacchetti NN, che gestisce gli elementi negativi sostituendoli con 0. Per accelerare l'intero processo per la rete neurale, utilizziamo le risorse della nostra scheda grafica se sono disponibili per l'utilizzo. Dai un'occhiata al codice di questo scenario nella seguente immagine apposta:

La funzione INIT è il metodo di inizializzazione in Pytorch. È necessario permettere a Pytorch di ottenere le directory contenenti librerie. In questo, l'abbiamo superato. Considerando che nella funzione in avanti, passiamo i tensori di input come parametri e la funzione in avanti restituisce i tensori di output calcolando i tensori di input. In questo, passiamo due parametri, "self" e "x", alla funzione in avanti. La funzione in avanti definisce anche come il tuo modulo funzionerà dall'input all'output.

Successivamente, l'output del codice precedente viene visualizzato nella seguente schermata:

Dopo il processo che abbiamo eseguito nei passaggi precedenti, addestreremo il nostro modello. Dobbiamo utilizzare un ottimizzatore e una funzione di perdita per raggiungere questo obiettivo. Una procedura di funzione di perdita determina la discrepanza tra l'output corrente di un algoritmo e l'output previsto. Optimizer aiuta il sistema a selezionare la scelta migliore da una serie di possibili opzioni che sono facili e non sfruttano i vincoli. Dai un'occhiata al codice di questo scenario nell'immagine apposta mostrata di seguito:

Epoch è un parametro che specifica il numero di volte in cui un algoritmo di apprendimento verrà eseguito attraverso il set di dati che abbiamo fornito per la formazione. Nel nostro caso, l'abbiamo impostato su 5, il che significa che passerà attraverso il nostro set di dati 5 volte durante l'allenamento.

Dopo aver inizializzato le epoche, useremo un loop per il numero di volte "t" che abbiamo dichiarato nelle epoche. In questo ciclo, eseguirà la funzione addestrata 5 volte e la eseguirà. Dopo tutto l'esecuzione "per loop", stamperà il testo "fatto".

Il seguente snippet visualizza l'uscita delle epoche addestrate:

Esempio 2

In questo caso, risolvendo il problema di adattarsi a y = sin (x) con un polinomio del terzo ordine sarà sufficiente.

Metodo 1

Il pacchetto ottimale fornito da Pytorch verrà utilizzato in questa tecnica. "Torcia.ottime ”è un pacchetto Pytorch responsabile dell'implementazione di diverse tecniche di ottimizzazione. La maggior parte delle tecniche usate di frequente sono già implementate e l'interfaccia è sufficientemente aperta che è possibile anche una futura integrazione facile di quelle più complesse. Modificando manualmente i tensori contenenti parametri apprendenti con torcia.Nessun grado, i pesi dei nostri modelli () vengono aggiornati.

Useremo anche il pacchetto NN per dichiarare il nostro modale, ma utilizzeremo RMSPOP per ottimizzare il modello perché fornisce il pacchetto di torce fornito da Optim.

Procediamo al nostro codice per creare un tensore responsabile della detenzione di dati per l'input e l'output. Nel nostro caso, abbiamo creato due variabili, "A" e "B". Successivamente, definiremo i tensori di input denominati "var" e "myvar", che sono tensori di input x^, x^2 e x^3.

Successivamente, dichiareremo funzioni modali e di perdita utilizzando il pacchetto NN. Crea un ottimizzatore utilizzando il pacchetto ottimale per modificare i pesi del modello per nostro conto. RMSPROP verrà utilizzato in questo caso; Il pacchetto ottimale include numerose altre tecniche di ottimizzazione. Il primo input del costruttore RMSPROP indica l'ottimizzatore su cui dovrebbe essere modificato. Crea un ottimizzatore utilizzando il pacchetto ottimale per modificare i pesi del modello per nostro conto. RMSPROP verrà utilizzato in questo caso; Il pacchetto ottimale include numerose altre tecniche di ottimizzazione. Il codice per la spiegazione precedente è disponibile nella seguente schermata Spyder:

Quindi, nel passaggio seguente, calcoleremo la preverata passandolo myvar:

$ y_pred = modal (myvar)

In esso, y_predicat è la variabile a cui assegniamo la funzione modale a cui viene passato il valore "myvar". La perdita verrà quindi calcolata e visualizzata. Ciò è causato dal fatto che i gradienti vengono raccolti dinamicamente nei buffer ogni volta.all'indietro () viene invocato.

perdita.all'indietro () determinerà il gradiente di perdita in considerazione del modale. Quando viene invocata la funzione Step di un ottimizzatore, i suoi parametri vengono aggiornati. Le caratteristiche di ingresso degli strati lineari vengono moltiplicate per la matrice di peso per generare le funzionalità di uscita. Le caratteristiche di input vengono passate a uno strato lineare come un tensore unidimensionale che è stato demolito e vengono moltiplicati per la matrice di peso. Alla fine del codice, visualizzerà l'output come risultato nella forma dell'equazione.

Metodo 2

Nel seguente metodo, useremo pacchetti tensori e autograti. Innanzitutto, importa le nostre biblioteche di torcia e matematica per questo programma e quindi definire le nostre variabili "dtype". Qui, abbiamo assegnato la torcia di valore.fluttuare come eseguito nell'esempio precedente e definito il "dispositivo" variabile. Assegniamo di nuovo la torcia di valore.dispositivo ("CPU") che viene utilizzato per definire la piattaforma da utilizzare.

Per trattenere ingressi e output, creare tensori. Supponendo che richieda grad = false, il passaggio all'indietro non deve calcolare i gradienti su questi tensori per impostazione predefinita. Crea pesi usando tensori casuali. Abbiamo bisogno di quattro pesi per un polinomio del terzo ordine: y = a + b x + c x^2 + d x^3 richieste di impostazione. Desideriamo calcolare i gradienti riguardanti questi tensori durante il passaggio all'indietro, che è indicato dal valore _Grad = true.

Calcola e visualizza la perdita utilizzando le funzioni tensori. La perdita diventa un tensore con la perdita di forma (1,). Il valore scalare della perdita viene restituito dall'articolo (). Il codice per la spiegazione precedente è disponibile nella seguente schermata Spyder:

In questo caso, il passaggio all'indietro della nostra rete neurale deve essere gestito manualmente. Non è fisicamente difficile per la rete a due strati semplice. Tuttavia, può rapidamente diventare complicato per grandi reti complesse. Fortunatamente, possiamo utilizzare la differenziazione automatica per meccanizzare il processo di un passaggio all'indietro nelle reti neurali. La libreria AutoGrad di Pytorch offre questa funzionalità in modo molto preciso; Durante l'utilizzo di AutoGrad, il passaggio in avanti di una rete caratterizzerà un grafico computazionale. Il grafico avrà nodi e bordi; I tensori sono rappresentati usando nodi e i bordi rappresentano i metodi che restituiranno i tensori di uscita prendendo i tensori di input come argomenti.

Leggere questo grafico aiuta a calcolare facilmente i gradienti. Questo sembra un compito difficile, ma in realtà questa pratica è molto semplice e semplice. Se "x" è un tensore e l'attributo "richiede grad" è impostato su True. Pertanto, x è un tensore che affronta un nodo in un grafico computazionale. X.La laurea è un altro tensore che tiene una pendenza di "x" per un certo valore scalare. Qui, dimostriamo l'adattamento di un'onda sinusoidale con un polinomiale di terzo ordine usando tensori Pytorch e autogrado. Ora, non è necessario per noi eseguire manualmente la pausa all'indietro attraverso la rete.

Metodo 3

In questo esempio, useremo il modulo numpy. Numpy è una libreria Python per il linguaggio di programmazione che supporta array e matrici sostanziali, multidimensionali. Inoltre, una quantità significativa di operazioni matematiche di alto livello per operare su questi array. Numpy è una piattaforma generica per il calcolo delle operazioni scientifiche; Non comporta grafici per l'apprendimento profondo o il calcolo.

Usando operazioni numpy, possiamo facilmente adattarci a un polinomio di terzo ordine in una funzione "peccato". Per fare ciò, per la prima volta importeremo le biblioteche numpy e matematica. La matematica è il pacchetto utilizzato per importare operazioni matematiche. Dai un'occhiata al codice di questo scenario nella seguente immagine:

Abbiamo inizializzato per la prima volta due variabili denominate "var1" e "var2" e abbiamo assegnato le loro funzioni. Qui, NP.La funzione Linspace è un metodo Python che ci aiuta a creare sequenze numeriche. Ci aiuta a generare vettori di spaziatura lineare. È lo stesso del segno del colon, ma l'unica differenza tra il segno del colon ed è che ci fornisce il controllo diretto sul numero di punti. A questa funzione, abbiamo superato tre parametri che sono "-math.pi "," matematica.pi "e" 200 ", in cui 200 è l'intervallo che il calcolo verrà eseguito. E la seconda funzione che abbiamo passato a var2 è "NP.sin (var1) ”, che viene utilizzato per calcolare il seno dei valori che verranno memorizzati in" var1 ".

Successivamente, abbiamo inizializzato quattro variabili denominate "A", "B", "C" e "D" a queste variabili abbiamo superato i valori casuali. Successivamente, abbiamo inizializzato A per loop a cui abbiamo superato la variabile "T", indicando il tempo e l'intervallo a 200.

Successivamente, definisci un'altra variabile, "var2_pred", a cui assegneremo l'operazione matematica per il calcolo dell'aggregato e quindi passarla alla variabile denominata "perdita". La perdita sarà responsabile del calcolo della perdita VAR "VAR2_PRED".

Passando al passaggio successivo, dove abbiamo usato l'istruzione IF, che sarà responsabile del calcolo del calcolo di "T%10 == 9", prenderà la modalità di "T" con il valore 10 e increderà di 9. Stamperà la perdita di questi valori ottenuti dall'istruzione IF precedente.

Dopo tutti questi calcoli in cui il loop termina, riassumerà gli interi valori e l'ultima operazione di stampa verrà calcolata alla fine del ciclo per e verrà visualizzato di conseguenza, come mostrato nello snippet di seguito:

Metodo 4

In questo pezzo di codice, useremo il pacchetto tensore. Un array numpy e un tensore di Pytorch sono teoricamente equivalenti perché un tensore è un array multidimensionale e Pytorch offre una varietà di metodi per lavorare con loro. I tensori sono uno strumento di elaborazione scientifica per uso generale che può monitorare gradienti e grafici computazionali in background. I tensori di Pytorch possono utilizzare le GPU per accelerare le loro operazioni numeriche, a differenza di Numpy. Un tensore di Pytorch può essere eseguito su una GPU in alcuni semplici passaggi.

In questo pezzo di codice, abbiamo importato due librerie, torcia e matematica. Dato che useremo una torcia in questo codice e funzionalità matematiche, abbiamo definito una variabile denominata "dtype". Abbiamo assegnato la torcia dei dati.fluttuare perché stiamo eseguendo operazioni matematiche che restituiranno i valori in punti. Per archiviare i valori decimali, utilizziamo il float del tipo di dati.

Quindi abbiamo dichiarato un'altra variabile denominata "dispositivo" con l'assegnazione della torcia.dispositivo ("CPU") perché abbiamo selezionato la CPU come piattaforma nell'installazione di Pytorch. Andando avanti, abbiamo inizializzato due variabili denominate var1 "e" var2 "e abbiamo assegnato loro la stessa funzione che abbiamo assegnato nell'esempio precedente. Quindi creando quattro variabili che sono "A", "B", "C" e "D" vengono utilizzate per creare tensori casuali. Ognuno ha la sua forma unica; Abbiamo anche superato il dispositivo di dati dati e il dType, che verranno inizializzati all'inizio del nostro codice. Quindi, utilizzerà le risorse della nostra CPU e prenderà valori sotto forma di decimali. È indicato che intendiamo calcolare i gradienti su tali tensori durante il passaggio inverso affermando che richiede grad = vero. Dai un'occhiata al codice di questo scenario nella seguente immagine apposta:

Quindi abbiamo dichiarato un apprendimento_rate = 1e-6. Il tasso di apprendimento è anche un iperparametro utilizzato per la formazione delle reti neurali. Ha un valore molto piccolo che deve essere maggiore di 0.0 e meno di 1.0, nel senso che deve essere un valore positivo. Il ritmo dell'apprendimento aumenta con l'aumento del tasso di apprendimento.

Dopodiché, apriremo un ciclo che verrà eseguito 200 volte e eseguirà operazioni matematiche sulle nostre variabili. Ovunque T%100 diventa uguale a 99, il ciclo stamperà il numero di volte in cui viene eseguito e fermato. Successivamente, il risultato verrà pubblicato quando la nostra iterazione termina, come visualizzato nella seguente screenshot:

Metodo 5

In questo metodo, creeremo la nostra funzione AutoGrad usando le sottoclassi Pytorch. Ogni autogrado primario è due metodi che operano sui tensori. La funzione in avanti prende i tensori di input e calcola i tensori di output da essi. A Pytorch, possiamo indubbiamente caratterizzare il nostro operatore di AutoGrad descrivendo una sottoclasse.autogrado.funzionare e eseguire gli approcci in avanti e indietro.

Ora, i tensori di output vengono procurati come parametri alle funzioni all'indietro con alcuni valori scalari. Pytorch ci facilita per definire il nostro operatore autogrado consentendoci di creare una sottoclasse che analizza il gradiente dei tensori di input con allusione agli stessi valori scadenti. Ora possiamo usare il nostro operatore di AutoGrad inizializzando un costruttore e chiamandolo un metodo. Quindi passeremo il tensore con i dati di input come parametro a quel costruttore.

Nel seguente esempio, specifichiamo il nostro modale come:

$ y = a+b p_3 (c+dx)
y = a+bp3 (c+dx)
invece di
y = a+bx+cx^2+dx^3
y = a+bx+cx2+dx3

Componiamo il nostro metodo AutoGrad personalizzato elaborando il avanti e indietro di P3 e utilizzandolo per eseguire il nostro modello. Il codice per la seguente spiegazione è disponibile sullo schermo Spyder.

Sottoclassando la torcia, potremmo implementare le nostre funzioni uniche di AutoGrad.autogrado. Pertanto, funzionare e mettere in pratica i passaggi in avanti e all'indietro che usano i tensori. Riceviamo un tensore che tiene in mano l'input durante il passaggio in avanti e consegniamo un tensore contenente l'output. Un oggetto di contesto chiamato CTX può essere utilizzato per archiviare i dati da utilizzare nel calcolo all'indietro.

I tensori possono essere creati per archiviare input e output. Supponendo che richieda grad = false, il passaggio all'indietro non deve calcolare i gradienti su questi tensori per impostazione predefinita.

Crea pesi usando tensori casuali. Per garantire la convergenza, i pesi per questo esempio dovrebbero essere introdotti ragionevolmente vicini al risultato accurato: y = a + b * p3 (c + d * x). È indicato che intendiamo generare un gradiente riguardante queste mappature durante un passaggio all'indietro mediante impostazione che richiede grad = true.

La seguente immagine dimostra l'output generato dal codice precedente:

Metodo 6

Qui useremo NN il modulo per risolvere questo problema. Dopo aver importato le nostre biblioteche desiderate torcia e matematica, dichiareremo tensori di assegnare input e output. Questo esempio può essere considerato una rete neurale a livello lineare poiché l'output risultante è una funzione lineare di (x2, x3). Dai un'occhiata al codice di questo scenario è la seguente immagine apposta:

Prediamo il tensore (x, x2, x3). Poiché P ha forma (3) e x.Unsqueeze (-1) ha una struttura (200, 1), la semantica in streaming verrà utilizzata per produrre un tensore di forma in questa situazione (200, 3). Per costruire il nostro modello come una serie di strati, utilizzare il pacchetto NN. NN è un modulo che applica altri moduli in sequenza per ottenere l'output, noto come modulo sequenziale. Il modulo lineare mantiene i tensori interni per la sua distorsione e il suo peso e utilizza una funzione lineare per calcolare l'uscita dall'ingresso. Per calcolare il passaggio all'indietro, utilizzare AutoGrad.

UN.Grad, b.Grad seguirà questa chiamata. I tensori che detengono il gradiente di una perdita riguardanti le lettere A, B, C e D sono designati come C.Grad e d.Grad, rispettivamente. Abbiamo utilizzato l'errore medio al quadrato (MSE) come nostra funzione di perdita, che è definita nel pacchetto NN insieme ad altre importanti funzioni di perdita.

Pass in avanti: dando il modello X, calcola la prevista y. L'operatore __Call__ è esteso dagli oggetti del modulo, permettendoti di chiamarli proprio come le funzioni. In tal modo, si fornisce al modulo un tensore di dati di input e restituisce un tensore dell'output previsto. Duplica e stampa perdita La funzione di perdita fornisce un tensore che contiene la perdita dopo aver ricevuto tensori da noi contenenti i valori veri e previsti di y.

Calcola il gradiente di una perdita relativa a ciascun parametro del modello apprendente durante il passaggio all'indietro. A causa della memorizzazione interna delle caratteristiche di ciascun modulo nei tensori che richiedono un set di laurea su True, questa funzione calcolerà i gradienti per tutti i parametri del modello apprendono. È possibile accedere al livello iniziale del modello selezionando il primo elemento da un elenco.

Finalmente, il risultato viene visualizzato utilizzando la funzione di stampa quando l'intera iterazione viene eseguita correttamente.

Metodo 7

Torcia.Il modulo NN è generalmente il blocco principale di Pytorch. Innanzitutto, definisci un NN.Oggetto modulo, quindi chiama la sua funzione in avanti per eseguirlo. Questo metodo di funzionamento è orientato agli oggetti. Una rete Relu completamente connessa include uno strato nascosto addestrato per prevedere y da x riducendo la distanza euclidea quadrata.

In questo caso, il modello è definito come una sottoclasse modulo specifica. Devi definire il tuo modello in questo modo ogni volta che vuoi che sia più complesso di un elenco semplice di tutti i moduli attualmente esistenti. Il codice per la spiegazione precedente è disponibile nella seguente schermata Spyder:

Quindi calcola il passaggio all'indietro usando AutoGrad. Il metodo determinerebbe il gradiente della perdita per tutti i tensori con gradchate richiesto = true. UN.Grad, b.Grad seguirà questa chiamata. I tensori che detengono il gradiente della perdita riguardanti le lettere A, B, C e D sono designati come C.Grad e d.Grad, rispettivamente. Possiamo anche definire una funzione personalizzata in Pytorch.

Dopo aver creato Class Polinomial3, dichiareremo tensori per trattenere l'input e l'output. Quattro argomenti vengono creati e assegnati come parametri del membro nella funzione. Se utilizzata con i moduli, la sottoclasse di tensori nota come parametro ha una proprietà molto unica. Se assegnato come attributi del modulo, il parametro viene automaticamente incluso nell'elenco dei parametri del modulo e apparirà nell'elenco dei parametri del modulo, E.G., in parametri () iteratore. Il metodo Parameters () in ciascun NN.Il modulo recupera le variabili addestrabili del modulo. Queste variabili devono essere esplicitamente definite.

La funzione in avanti richiede un tensore di dati di input e un tensore di dati di output. Possiamo applicare operatori arbitrari ai tensori e ai moduli definiti nel costruttore. Costruisci un ottimizzatore e la nostra funzione di perdita. I parametri addestrabili, che sono membri del modello e sono specificati con la torcia.nn.Il parametro nel costruttore SGD sarebbe incluso nella chiamata al modello.parametri (). Quindi nel passaggio in avanti, calcola il previsto y (y_pred) e passalo la variabile "var".Alla fine, i gradienti zero eseguiranno automaticamente il passaggio all'indietro ed eseguiranno i pesi.

La discesa a gradiente stocastico (SGD) è un ottimizzatore che appartiene alla famiglia di discesa gradiente ed è una nota tecnica di ottimizzazione utilizzata nell'apprendimento profondo e nell'apprendimento automatico. Il termine "stocastico" si riferisce a un sistema accoppiato o collegato a probabilità casuale nell'ottimizzatore SGD.

Alla fine, calcoleremo la perdita e la stamperemo assegnandola la funzione di criterio responsabile del calcolo della perdita. Abbiamo superato la y prevista e il modale che ci siamo allenati. Quindi dichiarando l'istruzione IF che sta calcolando la modalità per 10 dei valori variabili "t". Successivamente, lo increverà di 9 e il valore risultante di T viene passato alla funzione di stampa a cui verrà calcolata la perdita.

Alla fine del codice, il risultato verrà eseguito correttamente, come mostrato nella figura seguente:

Conclusione

L'applicazione dell'API Pytorch per le attività tipiche del modello di apprendimento profondo è l'obiettivo centrale del tutorial. Le informazioni che hai studiato in questo articolo dovrebbero rendere più semplice la messa a punto di eventuali concetti di Pytorch sofisticati che potresti aver pensato e imparare i moduli Pytorch dall'installazione di base del Pytorch su Python alla complessa formazione di un modello. Abbiamo anche discusso dei diversi modi per implementare un singolo esempio utilizzando moduli diversi, Numpy, Torch Tensor, Torch e AutoGrad, stabilendo una nuova funzione AutoGrad, funzione ottimale, moduli NN e anche il modulo NN personalizzato. La piattaforma utilizzata per eseguire il nostro codice è Spyder; Puoi utilizzare altre piattaforme, come Conda, Giove e Linux.