In questa sezione esamineremo la regressione lineare in una dimensione e come costruire il modello utilizzando PyTorch.
Nel video esamineremo: Semplice regressione lineare 1-D,
Il problema della previsione. In Pytorch copriremo i blocchi costitutivi della rete neurale tra cui:
The Class Linear, How to Build Custom Modules utilizzando NN.modules.
Regressione lineare è: Un metodo per aiutarci a capire la relazione
tra due variabili: Il predittore (indipendente) variabile x a volte chiamato una funzione
Il target (dipendente) variabile y
Vorremmo venire con una relazione lineare tra le variabili,
Questo è a volte chiamato una mappatura lineare ma nel caso unidimensionale è solo l'equazione di una linea
Il parametro è b bias, il parametro w uno
è la pendenza o in Pytorch questo è chiamato il peso.
Quando inseriamo o alleniamo il modello, inventeremo questi parametri. Lo chiamiamo un modello, in
quanto modella la relazione tra x e y. Chiariamo il passo di previsione.
La linea mapperà la variabile dipendente x, al valore stimato di y,
il cappello sulla y indica che è una stima.
In pytorch chiamiamo il passo di previsione il passo in avanti.
Nella regressione lineare abbiamo due passaggi: abbiamo una serie di punti di allenamento,
usiamo questi punti di allenamento per adattare o allenare il modello e ottenere parametri.
Usiamo quindi questi parametri nel modello. Ora abbiamo un modello;
usiamo il cappello sul y do denotare questo modello è una stima
Possiamo usare questo modello per prevedere qualsiasi valore di y dato qualsiasi x.
Prima di discutere come imparare i parametri,
vediamo come fare una previsione utilizzando alcuni valori arbitrari.
Creiamo due tensori che rappresentano il bias e la pendenza,
come dobbiamo impararli impostiamo l'opzione requires_grad=true.
In questo caso impostiamo la polarizzazione su -1 e la pendenza su 2.
Definiamo la funzione in avanti che farà la previsione che
chiamiamo l'input x, a destra includiamo un cappello per indicare che è una stima della vera y.
Creiamo un tensore PyTorch uno per uno. Quindi chiamiamo la funzione con il tensore x come input;
Stiamo semplicemente mappando x a y utilizzando l'equazione della linea, come mostrato sul lato destro dello schermo.
Un risultato è un tensore che rappresenta la nostra produzione.
Siamo in grado di applicare l'equazione della linea a più valori.
Ogni riga rappresenta un campione diverso, quindi creiamo un tensore con 2 righe e una colonna,
l'equivalente vettoriale è mostrato a sinistra. Inseriamo il tensore alla funzione,
e applica la funzione lineare ad ogni riga del tensore, a
sinistra mostriamo l'equivalente in cui ogni riga è di un colore diverso.
Il risultato è un nuovo tensore, per ogni riga del tensore è stata applicata la funzione lineare.
PyTorch ha costruito in pacchetti e classi, una classe utile è Lineare,
per ora questi pacchetti sembrano un po 'eccessivo
ma ci aiuterà a costruire modelli più complessi in seguito e sono un importante elemento costitutivo delle reti neurali.
Useremo il costruttore lineare per produrre un oggetto in questo caso chiamato modello,
useremo il modello a oggetti per fare una previsione.
Importiamo lineare dal pacchetto nn. La pendenza e la polarizzazione sono inizializzati casualmente,
per ottenere gli stessi risultati ogni volta che eseguiamo il codice usiamo il seme casuale,
impareremo come i parametri si ottengono nella sezione successiva,
Creiamo un oggetto modello utilizzando il costruttore lineare,
il parametro «in feature» è la dimensione di ogni input campione
o il numero di colonne, «out features» è la dimensione di ogni campione di output,
essenzialmente crea una funzione lineare come mostrato nel lato destro dello schermo.
Un metodo importante è i parametri, questo ci dà i parametri
del modello Il primo è la pendenza, il secondo è il bias,
dobbiamo applicare l'elenco delle funzioni python per ottenere un output poiché il metodo viene valutato pigramente.
Creiamo un tensore 1x1 per l'input, chiamiamo l'oggetto modello per fare una previsione,
non abbiamo bisogno di chiamare il metodo forward richiede esplicitamente solo le parentesi, il tensore è l'argomento.
L' uscita è un tensore 1x1.
Siamo in grado di inserire più valori, come prima di ogni campione è una riga in un tensore
Chiamiamo il modello a oggetti, e la polarizzazione viene aggiunto proprio come le operazioni vettoriali come mostrato a destra.
Questo equivale a chiamare il metodo in avanti.
Il risultato è un nuovo tensore, per ogni riga il valore viene moltiplicato per la pendenza e la polarizzazione viene aggiunta.
Per rivedere, per creare un modello di regressione lineare unidimensionale,
creiamo o istanziamo un oggetto lineare, in questo caso, lo chiamiamo il modello.
Invece di chiamare il metodo in avanti, usiamo semplicemente il nome dell'oggetto con l'input in questo caso x tra parentesi.
In Pytorch è consuetudine creare un modulo personalizzato per creare un modello, utilizzando il pacchetto NN.Module.
Questo è solo un oggetto Python.
Un modulo personalizzato ci permette di avvolgere più oggetti per creare moduli più complessi.
In questo esempio creeremo un modello personalizzato che utilizza solo un modello lineare, creeremo un modulo personalizzato per una regressione lineare.
I moduli personalizzati sono classi; queste classi sono la sottoclasse
o figli del pacchetto nn.Module.
In questo caso, chiamiamo il nostro modulo personalizzato LR.
Rendiamo la classe un figlio di NN.Modules, di conseguenza,
eredita tutti i metodi e gli attributi. Nel costruttore di oggetti,
l'argomento è la dimensione dell'input e dell'output, rispettivamente x e y.
Chiamiamo il super costruttore questo ci permette di creare oggetti dal pacchetto nn.Module
all'interno dell'oggetto senza inizializzarlo esplicitamente. Ora possiamo creare un oggetto di tipo lineare
gli argomenti sono impostati tramite il costruttore di oggetti,
lo assegniamo a self.linear possiamo ora chiamare l'oggetto di tipo lineare ovunque nella classe.
Usiamo la funzione in avanti per produrre una previsione.
Non dovremo chiamare esplicitamente il metodo forward basta usare parentesi in quanto si comporta come il metodo di chiamata in python
Creiamo un modello utilizzando il costruttore, gli argomenti sono la dimensione del modello,
i parametri sono inizializzati in modo casuale. In questo caso questa è solo l'equazione di una linea.
Nel laboratorio usiamo il metodo state_dict () [per cambiare i valori dei parametri,
ne parleremo un po 'più tardi. Puoi stampare la pendenza e il bias,
possiamo farlo perché l'oggetto è una sottoclasse di moduli.
Come prima creiamo un input.
Chiamiamo l'oggetto per generare un output, non dobbiamo richiamare in modo esplicito,
abbiamo solo bisogno di usare la parentesi. Il risultato è un nuovo tensore.
Possiamo usare il nostro modulo personalizzato per fare previsioni multiple
L'oggetto mappa ogni riga del tensore usando la linea.
Il risultato è un nuovo tensore, per ogni riga il valore viene moltiplicato per la pendenza e la polarizzazione viene aggiunto
In Sommario, ora creiamo un modulo personalizzato che è la nostra classe,
possiamo creare un oggetto di quella classe. Poiché la classe è un figlio di NN.Module,
possiamo ottenere i parametri tramite i parametri del metodo. Possiamo usare l'oggetto per fare una previsione,
non dobbiamo chiamare esplicitamente il metodo forward.
Infine, un metodo importante è state_dict ()
questo restituisce un dizionario python. Lo useremo man mano che i nostri modelli diventano più complessi.
Una funzione è quella di mappare la relazione dei livelli lineari ai suoi parametri.
possiamo stampare le chiavi e i valori. Ora vediamo come addestrare il modello.